如何識別並重新啓動使用java類啓動線程列表後已被終止的線程？

Question

我已經在我的課開始了20個線程，每個線程將運行在一個循環中做一些事情

for(int i=1;i<=20;i++) { 
    MyThread mt = new MyThread(i);     
    Thread t = new Thread(mt); 
    t.start(); 
} 

MyThread.java

public class MyThread implements Runnable{ 
    private int threadId; 
    public MyThread(int i) { 
     this.threadId = i; 
    } 
    @Override 
    public void run() { 
     if(threadId > 0) { 
      while(1) { 
       try { 
        //do something 
       } catch(Exception ex) { 
        //do nothing 
       } 
      } 
     } 
    } 
} 

現在我要監控每個線程，如果他們中的任何人停止，我想用相應的threadId啓動一個新的線程。我怎樣才能做到這一點？請幫幫我。

Answer 1

如果你想測試線程然後繼續線程的列表中的數組：

MyThread[] mt = new MyThread[20]; 
... 
mt[i] = ... 

現在你可以從Thread類方法的每個線程上查詢，例如：的IsAlive（）;

Answer 2

我將從Thread類的可能狀態開始。有6種可能的狀態：

Enum Thread.State

新：還沒有開始就處於這種狀態的線程。

RUNNABLE：在Java虛擬機中執行的線程處於此 狀態。

BLOCKED：阻塞等待顯示器鎖定的線程處於 此狀態。

WAITING：等待無限期地等待另一個線程執行特定動作的線程處於此狀態。

TIMED_WAITING：正在等待另一個線程執行的線程 對於達到指定等待時間的操作處於此狀態。

TERMINATED：退出的線程處於此狀態。

正如你所說的那樣「已被殺死」的線程是處於終止狀態的線程。有兩個主要原因會導致終止狀態。

• A）run（）方法在他的工作後正常退出。
• B）發生異常，run（）方法結束。

如果你想讓你的線程「永不」進入終止模式，那麼你應該A）有一個無限循環B）捕獲所有異常。但那不完全是你的問題。如何監視線程​​的狀態？

主要是getState()方法

公共Thread.State的getState（）

返回該線程的狀態。此方法設計用於監視系統狀態，而不是用於同步控制。

你可以做你想做的有以下3類：

App.java

package com.what.ever; 

import java.util.ArrayList; 
import java.util.List; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ScheduledExecutorService; 
import java.util.concurrent.TimeUnit; 

public class App { 

    private static int MONITORING_FREQUENCY = 5; 
    private static int NUMBER_OF_TASKS = 3; 

    public static void main(String[] args) { 
     List<ThreadMonitor> threadMonitors = initThreadMonitors(); 

     threadMonitors.forEach(m -> m.printState()); 
     threadMonitors.forEach(m -> m.startThread()); 

     ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); 
     scheduler.scheduleAtFixedRate(() -> threadMonitors.forEach(m -> m.restartIfTerminated()), MONITORING_FREQUENCY, MONITORING_FREQUENCY, TimeUnit.SECONDS); 
    } 

    private static List<ThreadMonitor> initThreadMonitors() { 
     List<ThreadMonitor> threadMonitors = new ArrayList<>(); 

     for (int i = 1; i <= NUMBER_OF_TASKS; i++) { 
      DummyRunnable runnable = new DummyRunnable(i); 
      ThreadMonitor threadMonitor = new ThreadMonitor(runnable); 
      threadMonitors.add(threadMonitor); 
     } 

     return threadMonitors; 
    } 
} 

ThreadMonitor.java

package com.what.ever; 

public class ThreadMonitor { 

    private Thread thread; 
    private DummyRunnable runnable; 

    public ThreadMonitor(DummyRunnable runnable) { 
     this.runnable = runnable; 
     this.thread = new Thread(runnable); 
    } 

    public boolean startThread() { 
     boolean isStarCalled = false; 
     if(Thread.State.NEW.equals(thread.getState())) { 
      thread.start(); 
      isStarCalled = true; 
     } 
     return isStarCalled; 
    } 

    public void printState() { 
     System.out.println(thread.toString() + " is in state : " + thread.getState()); 
    } 

    public void restartIfTerminated() { 
     printState(); 
     if(Thread.State.TERMINATED.equals(thread.getState())) { 
      thread = new Thread(runnable); 
      thread.start(); 
     } 
    } 
} 

DummyRunnable.java

package com.what.ever; 

public class DummyRunnable implements Runnable { 

    private int id; 

    public DummyRunnable(int id) { 
     this.id = id; 
    } 

    public void run() { 
     System.out.println("Runnable " + id + " started in thread: " + Thread.currentThread()); 
     dummyWork(); 
     System.out.println("Runnable " + id + " done"); 
    } 

    private void dummyWork() { 
     int sleep = 10000; 
     if (id == 3) { 
      sleep = 1000; 
     } 
     try { 
      Thread.sleep(sleep); 
     } catch (Exception e) { 
      System.out.print(e); 
     } 
    } 
} 

在這裏，你去。如果您對這個例子有任何疑問，只需詢問。

小警告： 小心監控頻率，會對性能產生巨大影響。不要試圖用這個做實時應用。