java 线程状态

Java中线程的生命周期分为6种状态:

• NEW. 初始状态，线程被构建，但未调用start()方法
• RUNNABLE. 运行状态，调用start()方法后。在java线程中，将操作系统线程的就绪和运行统称运行状态
• BLOCKED. 阻塞状态，线程等待进入synchronized代码块或方法中，等待获取锁
• WAITING. 等待状态，线程可调用wait、join等操作使自己陷入等待状态，并等待其他线程做出特定操作（如notify或中断）
• TIMED_WAITING. 超时等待，线程调用sleep(timeout)、wait(timeout)等操作进入超时等待状态，超时后自行返回
• TERMINATED. 终止状态，线程运行结束

获取线程状态

// 以整数的形式保存线程的状态
private volatile int threadStatus = 0;

// 返回当前线程的状态，一个枚举类型值
public State getState() {
  return sun.misc.VM.toThreadState(threadStatus);
}

static void showThreadStatus(Thread thrd) {
      System.out.println(thrd.getName()+" 存活:" +thrd.isAlive()+" 状态:" + thrd.getState() );
   }

线程生命周期示例

public class ThreadTest {
 
    static final Object obj = new Object();
 
    private static boolean flag = false;
 
    public static void main(String[] args) throws Exception {
 
        Thread consume = new Thread(new Consume(), "Consume");
        Thread produce = new Thread(new Produce(), "Produce");
        consume.start();
        Thread.sleep(1000);
        produce.start();
 
        try {
            produce.join(); // main 线程处于 WAITING 状态
            consume.join(); // main 线程处于 WAITING 状态
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    // 生产者线程
    static class Produce implements Runnable {
 
        @Override
        public void run() {
 
            synchronized (obj) {
                System.out.println("进入生产者线程");
                System.out.println("生产");
                try {
                    TimeUnit.MILLISECONDS.sleep(2000);  //模拟生产程
                    flag = true;
                    obj.notify();  // 通知消费者
                    TimeUnit.MILLISECONDS.sleep(1000);  //模拟其他时操作
                    System.out.println("退出生产者线程");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
    //消费者线程
    static class Consume implements Runnable {
 
        @Override
        public void run() {
            synchronized (obj) {
                System.out.println("进入消费者线程");
                System.out.println("wait flag 1:" + flag);
                while (!flag) {  //判断条件是否满足，若不满足则等待
                    try {
                        System.out.println("还没生产，进入等待");
                        obj.wait();  // Consume 线程处于 WAITING 状态
                        System.out.println("结束等待");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("wait flag 2:" + flag);
                System.out.println("消费");
                System.out.println("退出消费者线程");
            }
 
        }
    }
}