Trong Java, làm cách nào để xác định xem một luồng có đang chạy hay không?

Câu trả lời:

93

Thread.isAlive()

— Wayne
nguồn
Tôi đoán nó có sự chênh lệch so Thread.State.RUNNABLE(người cuối cùng dường như đáng tin cậy hơn)
— user924
33

Bạn có thể sử dụng phương pháp này:

boolean isAlive()

Nó trả về true nếu thread vẫn còn sống và false nếu Thread đã chết. Đây không phải là tĩnh. Bạn cần một tham chiếu đến đối tượng của lớp Thread.

Một mẹo nữa: Nếu bạn đang kiểm tra trạng thái của nó để làm cho luồng chính đợi trong khi luồng mới vẫn đang chạy, bạn có thể sử dụng phương thức join (). Nó là tiện dụng hơn.

— Abdulsattar Mohammed
nguồn
9

Kiểm tra trạng thái luồng bằng cách gọi Thread.isAlive.

— sth
nguồn
6

Để được chính xác,

Thread.isAlive() trả về true nếu luồng đã được bắt đầu (có thể chưa chạy) nhưng chưa hoàn thành phương thức chạy của nó.

Thread.getState() trả về trạng thái chính xác của luồng.

— sxnamit
nguồn
5

Lớp enum Thread.State và API getState () mới được cung cấp để truy vấn trạng thái thực thi của một luồng.

Một luồng chỉ có thể ở một trạng thái tại một thời điểm nhất định. Các trạng thái này là trạng thái máy ảo không phản ánh bất kỳ trạng thái luồng nào của hệ điều hành [ NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED].

enum Thread.State mở rộng Enum triển khai Serializable , Comp Compare

  • getState ()jdk5 - public State getState() {...} « Trả về trạng thái của thisluồng. Phương pháp này được thiết kế để sử dụng trong việc giám sát trạng thái hệ thống, không phải để điều khiển đồng bộ hóa.

  • isAlive () - public final native boolean isAlive(); « Trả về true nếu luồng mà nó được gọi vẫn còn tồn tại, nếu không thì trả về false . Một luồng vẫn sống nếu nó đã được bắt đầu và chưa chết.

Mã nguồn mẫu của các lớp java.lang.Threadvà 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;
        }
    }
}

Ví dụ với java.util.concurrent.CountDownLatchđể thực thi nhiều luồng song song, Sau khi hoàn thành tất cả các luồng thực thi luồng chính. (cho đến khi các luồng song song hoàn thành nhiệm vụ của chúng, luồng chính sẽ bị chặn.)

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

@Xem thêm

— Yash
nguồn
A thread is alive if it has been started and has not yet died. Chết có nghĩa là gì? Nhà nước là TERMINATED?
— KunLun
2

Yêu cầu chủ đề của bạn thông báo cho một số chủ đề khác khi nó kết thúc. Bằng cách này, bạn sẽ luôn biết chính xác những gì đang xảy ra.

— Bombe
nguồn
1

Nghĩ rằng viết một đoạn mã để chứng minh các phương thức isAlive (), getState () , ví dụ này giám sát một luồng mà nó vẫn kết thúc (chết).

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
nguồn
1

Bạn có thể sử dụng: Thread.currentThread().isAlive();. Trả về true nếu luồng này còn tồn tại; sai khác.

— Sou
nguồn
1

Sử dụng Thread.currentThread (). IsAlive () để xem liệu luồng có còn sống hay không [đầu ra phải là true] có nghĩa là luồng vẫn đang chạy mã bên trong phương thức run () hoặc sử dụng phương thức Thread.currentThread.getState () để lấy trạng thái chính xác của chủ đề.

— Hasindu Dahanayake
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.