En Java, ¿cómo se determina si se está ejecutando un hilo?

¿Cómo se determina si se está ejecutando un hilo?

Thread.isAlive()

Puede utilizar este método:

boolean isAlive()

Devuelve verdadero si el hilo todavía está vivo y falso si el hilo está muerto. Esto no es estático. Necesita una referencia al objeto de la clase Thread.

Un consejo más: si está comprobando su estado para hacer que el hilo principal espere mientras el nuevo hilo aún se está ejecutando, puede usar el método join (). Es más útil.

Creo que puedes usar GetState () ; Puede devolver el estado exacto de un hilo.

Verifique el estado del hilo llamando Thread.isAlive.

Para ser preciso,

Thread.isAlive() devuelve verdadero si el hilo se ha iniciado (es posible que aún no se esté ejecutando) pero aún no ha completado su método de ejecución.

Thread.getState() devuelve el estado exacto del hilo.

La clase de enumeración Thread.State y la nueva API getState () se proporcionan para consultar el estado de ejecución de un hilo.

Un hilo puede estar en un solo estado en un momento dado. Estos estados son estados de máquinas virtuales que no reflejan ningún estado de subproceso del sistema operativo [ NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED].

enum Thread.State extiende Enum implementa Serializable , Comparable

• getState ()^jdk5 - public State getState() {...} « Devuelve el estado del thishilo. Este método está diseñado para su uso en la supervisión del estado del sistema, no para el control de sincronización.

• isAlive () - public final native boolean isAlive(); « Devuelve verdadero si el hilo en el que se llama aún está vivo, de lo contrario, devuelve falso . Un hilo está vivo si se ha iniciado y aún no ha muerto.

Ejemplo de código fuente de clases java.lang.Thready 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;
        }
    }
}

Ejemplo con java.util.concurrent.CountDownLatchpara ejecutar varios subprocesos en paralelo, después de completar todos los subprocesos ejecutar el subproceso principal. (Hasta que los subprocesos paralelos completen su tarea, se bloqueará el subproceso principal).

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

@Ver también

• "Implementa Runnable" frente a "Extend Thread"
• Estados del hilo
• Diagrama de estados de hilo
• Cómo iniciar dos subprocesos "exactamente" al mismo tiempo

Haga que su hilo notifique a otro hilo cuando esté terminado. De esta forma siempre sabrás exactamente lo que está pasando.

Pensado para escribir un código para demostrar los métodos isAlive (), getState () , este ejemplo monitorea un hilo aún termina (muere).

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


}

Se puede utilizar: Thread.currentThread().isAlive();. Devuelve verdadero si este hilo está vivo; falso de lo contrario.

Use Thread.currentThread (). IsAlive () para ver si el hilo está vivo [la salida debe ser verdadera] lo que significa que el hilo todavía está ejecutando el código dentro del método run () o use el método Thread.currentThread.getState () para obtener el estado exacto del hilo.