Wie identifizieren und starten Sie die Threads, die nach dem Start einer Thread-Liste mit der Java-Klasse beendet wurden?

Question

Ich habe 20 Fäden in meiner Klasse begonnen hat, wird jeder Thread in einer Schleife laufen etwas

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 
       } 
      } 
     } 
    } 
} 

Jetzt möchte ich jeden Thread überwachen und wenn jemand von ihnen zu tun stoppt, ich möchte einen neuen Thread mit der entsprechenden threadId starten. Wie kann ich das machen? Bitte hilf mir.

Answer 1

Wenn Sie Threads testen, dann eine Liste von Threads in einem Array halten:

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

Jetzt können Sie mit Methoden aus der Klasse Thread auf jeden Thread fragen, zum Beispiel: IsAlive();

Answer 2

Ich werde mit den möglichen Zuständen der Thread-Klasse beginnen. Es gibt 6 mögliche Zustände:

Enum Thread.State

NEU: Ein Thread, der noch nicht begonnen hat in diesem Zustand befindet.

RUNNABLE: Ein Thread, der in der Java Virtual Machine ausgeführt wird, befindet sich in diesem -Status.

BLOCKIERT: Ein Thread, der blockiert ist, wartet auf eine Monitorsperre ist in diesem Zustand.

WARTEN: Ein Thread, der unendlich lange auf einen anderen Thread wartet, um eine bestimmte Aktion auszuführen, befindet sich in diesem Zustand.

TIMED_WAITING: Ein Thread, der darauf wartet, dass ein anderer Thread ausführt, ist in diesem Zustand eine Aktion für eine bestimmte Wartezeit.

BEENDEN: Ein Thread, der beendet wurde, befindet sich in diesem Zustand.

Threads, die wie gesagt "getötet" wurden, sind diejenigen im "Terminated" -Zustand. Es gibt zwei Hauptursachen, die zum Zustand "Beendet" führen.

A) Die run() - Methode wird nach der Arbeit normal beendet.

B) Ausnahme tritt auf und run() Methode beendet.

Wenn Sie wollen, dass Ihre Threads "nie" im Terminated-Modus gehen, dann sollten Sie A) eine Endlosschleife haben B) alle Ausnahmen abfangen. Aber das war nicht genau deine Frage. Wie überwache ich den Zustand der Threads?

Schlüssel ist die Methode getState()

public Thread.State getState()

gibt den Status dieses Fadens. Diese Methode wurde für die Überwachung des Systemstatus und nicht für die Synchronisationskontrolle entwickelt.

können Sie tun, was Sie mit den folgenden drei Klassen wollen:

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); 
     } 
    } 
} 

Hier gehen Sie. Wenn Sie Fragen zu diesem Beispiel haben, fragen Sie einfach.

Kleine Warnungen: Seien Sie vorsichtig mit der Überwachungsfrequenz, es kann große Auswirkungen auf die Leistungen haben. Versuchen Sie nicht, Echtzeit-Anwendung mit diesem zu tun.