Wie stellen Sie in Java fest, ob ein Thread ausgeführt wird?

Wie stellen Sie fest, ob ein Thread ausgeführt wird?

Thread.isAlive()

Sie können diese Methode verwenden:

boolean isAlive()

Es gibt true zurück, wenn der Thread noch aktiv ist, und false, wenn der Thread tot ist. Dies ist nicht statisch. Sie benötigen einen Verweis auf das Objekt der Thread-Klasse.

Noch ein Tipp: Wenn Sie den Status überprüfen, damit der Hauptthread wartet, während der neue Thread noch ausgeführt wird, können Sie die join () -Methode verwenden. Es ist praktischer.

Ich denke, Sie können GetState () verwenden ; Es kann den genauen Status eines Threads zurückgeben.

Überprüfen Sie den Thread-Status durch Aufrufen Thread.isAlive.

Um genau zu sein,

Thread.isAlive() Gibt true zurück, wenn der Thread gestartet wurde (möglicherweise noch nicht ausgeführt wird), aber seine Ausführungsmethode noch nicht abgeschlossen hat.

Thread.getState() Gibt den genauen Status des Threads zurück.

Die Enumer- Klasse Thread.State und die neue API getState () dienen zum Abfragen des Ausführungsstatus eines Threads.

Ein Thread kann sich zu einem bestimmten Zeitpunkt nur in einem Zustand befinden. Diese Zustände sind Zustände der virtuellen Maschine, die keine Betriebssystem-Thread-Zustände [ NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED] widerspiegeln .

enum Thread.State erstreckt Enum Arbeitsgeräte Serialisierbar , Vergleichbar

• getState ()^jdk5 - public State getState() {...} « Gibt den Status des thisThreads zurück. Diese Methode dient zur Überwachung des Systemstatus und nicht zur Synchronisationssteuerung.

• isAlive () - public final native boolean isAlive(); « Gibt true zurück, wenn der Thread, für den es aufgerufen wird, noch aktiv ist, andernfalls false . Ein Thread ist aktiv, wenn er gestartet wurde und noch nicht gestorben ist.

Beispielquellcodes von Klassen java.lang.Threadund sun.misc.VM.

package java.lang;
public class Thread implements Runnable {
    public final native boolean isAlive();

    // Java thread status value zero corresponds to state "NEW" - 'not yet started'.
    private volatile int threadStatus = 0;

    public enum State {
        NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;
    }

    public State getState() {
        return sun.misc.VM.toThreadState(threadStatus);
    }
}

package sun.misc;
public class VM {
    // ...
    public static Thread.State toThreadState(int threadStatus) {
        if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) {
            return Thread.State.RUNNABLE;
        } else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) {
            return Thread.State.BLOCKED;
        } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) {
            return Thread.State.WAITING;
        } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) {
            return Thread.State.TIMED_WAITING;
        } else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) {
            return Thread.State.TERMINATED;
        } else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) {
            return Thread.State.NEW;
        } else {
            return Thread.State.RUNNABLE;
        }
    }
}

Beispiel mit java.util.concurrent.CountDownLatch, um mehrere Threads parallel auszuführen. Nach Abschluss aller Threads wird der Hauptthread ausgeführt. (Bis parallele Threads ihre Aufgabe abgeschlossen haben, wird der Haupt-Thread blockiert.)

public class MainThread_Wait_TillWorkerThreadsComplete {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Main Thread Started...");
        // countDown() should be called 4 time to make count 0. So, that await() will release the blocking threads.
        int latchGroupCount = 4;
        CountDownLatch latch = new CountDownLatch(latchGroupCount);
        new Thread(new Task(2, latch), "T1").start();
        new Thread(new Task(7, latch), "T2").start();
        new Thread(new Task(5, latch), "T3").start();
        new Thread(new Task(4, latch), "T4").start();

        //latch.countDown(); // Decrements the count of the latch group.

        // await() method block until the current count reaches to zero
        latch.await(); // block until latchGroupCount is 0
        System.out.println("Main Thread completed.");
    }
}
class Task extends Thread {
    CountDownLatch latch;
    int iterations = 10;
    public Task(int iterations, CountDownLatch latch) {
        this.iterations = iterations;
        this.latch = latch;
    }
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName + " : Started Task...");
        for (int i = 0; i < iterations; i++) {
            System.out.println(threadName + " : "+ i);
            sleep(1);
        }
        System.out.println(threadName + " : Completed Task");
        latch.countDown(); // Decrements the count of the latch,
    }
    public void sleep(int sec) {
        try {
            Thread.sleep(1000 * sec);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

@Siehe auch

• "Implementiert Runnable" vs. "erweitert Thread"
• Thread-Zustände
• Gewindezustandsdiagramm
• So starten Sie zwei Threads „genau“ gleichzeitig

Lassen Sie Ihren Thread einen anderen Thread benachrichtigen, wenn er fertig ist. Auf diese Weise wissen Sie immer genau, was los ist.

Dieses Beispiel soll einen Code schreiben, um die Methoden isAlive () und getState () zu demonstrieren. Es überwacht einen Thread, der noch beendet wird (stirbt).

package Threads;

import java.util.concurrent.TimeUnit;

public class ThreadRunning {


    static class MyRunnable implements Runnable {

        private void method1() {

            for(int i=0;i<3;i++){
                try{
                    TimeUnit.SECONDS.sleep(1);
                }catch(InterruptedException ex){}
                method2();
            }
            System.out.println("Existing Method1");
        }

        private void method2() {

            for(int i=0;i<2;i++){
                try{
                    TimeUnit.SECONDS.sleep(1);
                }catch(InterruptedException ex){}
                method3();
            }
            System.out.println("Existing Method2");
        }

        private void method3() {

            for(int i=0;i<1;i++){
                try{
                    TimeUnit.SECONDS.sleep(1);
                }catch(InterruptedException ex){}

            }
            System.out.println("Existing Method3");
        }

        public void run(){
            method1();
        }
    }


    public static void main(String[] args) {

        MyRunnable runMe=new MyRunnable();

        Thread aThread=new Thread(runMe,"Thread A");

        aThread.start();

        monitorThread(aThread);

    }

    public static void monitorThread(Thread monitorMe) {

        while(monitorMe.isAlive())
         {
         try{   
           StackTraceElement[] threadStacktrace=monitorMe.getStackTrace();

           System.out.println(monitorMe.getName() +" is Alive and it's state ="+monitorMe.getState()+" ||  Execution is in method : ("+threadStacktrace[0].getClassName()+"::"+threadStacktrace[0].getMethodName()+") @line"+threadStacktrace[0].getLineNumber());  

               TimeUnit.MILLISECONDS.sleep(700);
           }catch(Exception ex){}
    /* since threadStacktrace may be empty upon reference since Thread A may be terminated after the monitorMe.getStackTrace(); call*/
         }
        System.out.println(monitorMe.getName()+" is dead and its state ="+monitorMe.getState());
    }


}

Sie können verwenden : Thread.currentThread().isAlive();. Gibt true zurück, wenn dieser Thread aktiv ist. sonst falsch .

Verwenden Sie Thread.currentThread (). IsAlive () , um festzustellen , ob der Thread aktiv ist [Ausgabe sollte wahr sein], was bedeutet, dass der Thread den Code noch in der run () -Methode ausführt , oder verwenden Sie die Thread.currentThread.getState () -Methode, um den zu erhalten genauer Zustand des Threads.