thread用法 在Java中,如何确定线程是否正在运行?




java线程 (7)

您可以使用此方法:

boolean isAlive()

如果线程仍处于活动状态,则返回true;如果线程已死,则返回false。 这不是一成不变的。 您需要对Thread类的对象的引用。

还有一个提示:如果您正在检查它的状态以使主线程在新线程仍在运行时等待,则可以使用join()方法。 它更方便。

如何确定线程是否正在运行?


确切地说,

如果线程已经启动(可能尚未运行)但尚未完成其run方法,则Thread.isAlive()返回true。

Thread.getState()返回线程的确切状态。


通过调用Thread.isAlive检查线程状态。


提供了Thread.State枚举类和新的getState() API,用于查询线程的执行状态。

线程在给定时间点只能处于一种状态。 这些状态是虚拟机状态,不反映任何操作系统线程状态 [ NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED ]。

枚举Thread.State扩展Enum实现Serializable , Comparable

  • getState() jdk5 - public State getState() {...} « 返回this线程的状态。 此方法设计用于监视系统状态,而不是用于同步控制。

  • isAlive() - public final native boolean isAlive(); « 如果调用它的线程仍处于活动状态,则返回true ,否则返回false 如果一个线程已经启动并且还没有死亡,它就是活着的。

示例源代码类java.lang.Threadsun.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”与“扩展线程”
  • 线程状态
  • 线程状态图
  • 如何在“完全”同时启动两个线程

Thread.isAlive()


我想你可以使用GetState() ; 它可以返回线程的确切状态。


考虑编写一个代码来演示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());
    }


}




multithreading