在Java中，如何确定线程是否正在运行？

Question

在Java中，如何确定线程是否正在运行？

javamultithreading

97

如何确定线程是否在运行？

- cay

10个回答

34

你可以使用这种方法：

boolean isAlive()

如果线程仍然存活，则返回true，如果线程已死则返回false。这不是静态的。您需要对Thread类的对象进行引用。

再提醒一点：如果您正在检查它的状态以使主线程在新线程仍在运行时等待，可以使用join()方法。它更加方便。

- Abdulsattar Mohammed

21

我认为你可以使用 GetState()方法；它可以返回线程的确切状态。

- Chathuranga Chandrasekara

9

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

- javablogger390

8

确切地说,

Thread.isAlive() 返回 true，如果线程已经启动（可能还没有运行）但还没有完成其运行方法。

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

- sxnamit

6

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

示例使用java.util.concurrent.CountDownLatch来并行执行多个线程，当所有线程都完成后，主线程执行。(在并行线程完成任务之前，主线程将被阻塞。)

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

@参见

- Yash

一个线程如果已经启动并且尚未终止，就是活着的。什么是“终止”？指的是状态为“TERMINATED”吗？ - KunLun

2

当线程完成时，让它通知其他线程。这样你就始终知道正在发生什么。

- Bombe

2

你可以使用：Thread.currentThread().isAlive();。如果此线程仍活着则返回true，否则返回false。

- Sou

1

这个会一直返回true吗？我认为它必须是另一个线程的句柄。毕竟，当前线程不是在执行 Thread.currentThread().isAlive() 吗？因此总是返回true？ - Matthew

2

使用 Thread.currentThread().isAlive() 来查看线程是否存活[输出应该为true]，这意味着线程仍在运行 run() 方法中的代码，或者使用 Thread.currentThread.getState() 方法来获取线程的确切状态。

- Hasindu Dahanayake

1

本文旨在编写一段代码，演示 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());
    }


}

- Roshan

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Wayne · Accepted Answer

99

Thread.isAlive()

- Wayne

我猜它和 Thread.State.RUNNABLE 有一些不同（后者似乎更可靠）. - user924