В Java, как вы определяете, работает ли поток?

Question

Как вы определяете, работает ли поток?

Answer 1

Thread.isAlive()

Answer 2

Вы можете использовать этот метод:

boolean isAlive()

Он возвращает истину, если поток все еще жив, и ложь, если нить мертва. Это не статично. Вам нужна ссылка на объект класса Thread.

Еще один совет: если вы проверяете его состояние, чтобы заставить главный поток ждать, пока новый поток все еще работает, вы можете использовать метод join(). Это более удобно.

Answer 3

Я думаю, что вы можете использовать GetState (); Может возвращать точное состояние потока.

Answer 4

Проверьте статус потока, позвонив Thread.isAlive,

Answer 5

Точнее,

Thread.isAlive() возвращает true, если поток был запущен (возможно, еще не запущен), но еще не завершил свой метод run.

Thread.getState() возвращает точное состояние потока.

Answer 6

Класс enum Thread.State и новый API getState () предназначены для запроса состояния выполнения потока.

Поток может находиться только в одном состоянии в данный момент времени. Эти состояния являются состояниями виртуальных машин, которые не отражают состояния потоков операционной системы [ NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED ].

enum Thread.State расширяет Enum реализует Serializable, Comparable

• GetState () jdk5 - public State getState() {...} " Возвращает состояние this нить. Этот метод предназначен для использования в мониторинге состояния системы, а не для контроля синхронизации.

• isAlive () - public final native boolean isAlive(); " Возвращает true, если поток, для которого он вызван, еще жив, в противном случае он возвращает false. Поток жив, если он был запущен и еще не умер.

Пример исходного кода классов java.lang.Thread а также 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;
        }
    }
}

---

Пример:

public class WorkerThreadsWait {
    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("ThreadGroup1");

        CountDownLatch latch = new CountDownLatch(1);

        MyThread runnableTarget1 = new MyThread(latch, 5);
        Thread thread = new Thread(group, runnableTarget1, "Thread_1");
        thread.start();

        MyThread runnableTarget2 = new MyThread(latch, 50);
        Thread thread2 = new Thread(group, runnableTarget2, "Thread_2");
        thread2.start();
        thread2.setPriority( Thread.MIN_PRIORITY );

        MyThread runnableTarget3 = new MyThread(latch, 50);
        Thread thread3 = new Thread(group, runnableTarget3, "Thread_3");
        thread3.start();
        thread3.setPriority( Thread.MAX_PRIORITY );

        System.out.println("main Tread Execution started.");

        for (int i = 0; i < 10; i++) {
            System.out.println("Main \t : "+i);
            if( i == 2 ) {
                latch.countDown(); //This will inform all the waiting threads to start
                sleepThread( 1 );
            }
        }

        try {

            State state = thread.getState();
            boolean alive = thread.isAlive();
            System.out.format("State : %s, IsAlive: %b \n", state, alive);

            if( alive ) {
                System.out.println(" => Thread has started. So, joining it to main thread.");
                thread.join();
                System.out.println("Main Thread waits till the Joined thread's to treminate ('not-alive').");
                sleepThread( 1 );

                group.stop();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Main Thread Execution completed.");
    }

    static void sleepThread(int sec) {
        try {
            Thread.sleep( 1000 * sec );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyThread implements Runnable {
    CountDownLatch latch;
    int repeatCount;

    public MyThread(CountDownLatch latch, int repeatCount) {
        this.latch = latch;
        this.repeatCount = repeatCount;
    }
    @Override
    public void run() {
        try {
            String name = Thread.currentThread().getName();
            System.out.println("@@@@@ Thread : "+name+" started");

            latch.await(); //The thread keeps waiting till it is informed.

            System.out.println("@@@@@ Thread : "+name+" notified");
            for (int i = 0; i < repeatCount; i++) {
                WorkerThreadsWait.sleepThread( 1 );
                System.out.println("\t "+ name +": "+i);
            }
        } catch (InterruptedException e) {
        e.printStackTrace();
        }
    }
}

@Смотрите также

• "Реализует Runnable" против "расширяет поток"
• Состояния потоков
• Диаграмма состояний потоков
• Как запустить два потока в одно и то же время

Answer 7

Ты можешь использовать: Thread.currentThread().isAlive();. Возвращает истину, если этот поток жив; иначе ложь.

Answer 8

Пусть ваш поток уведомит другой поток, когда он закончится. Таким образом, вы всегда будете точно знать, что происходит.

Answer 9

Используйте Thread.currentThread(). IsAlive(), чтобы увидеть, жив ли поток[вывод должен быть истинным], что означает, что поток все еще выполняет код внутри метода run () или используйте метод Thread.currentThread.getState(), чтобы получить точное состояние резьбы.

Answer 10

Мысль написать код для демонстрации методов isAlive(), getState(), этот пример отслеживает поток, но он завершается (умирает).

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


}