Java线程的几种状态

2018-08-10

Java的线程的生命周期大体可以分为5种状态

1.新建状态(New) : 新创建了一个线程对象。

2.就绪状态(Runnable) :线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码

4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
(一)、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
(二)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
(三)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

Alt text

Jstack中几种线程状态

NEW 状态是指线程刚创建, 尚未启动

RUNNABLE 线程运行中或I/O等待

BLOCKED 线程在等待monitor锁(synchronized关键字)

WAITING 线程在无限等待唤醒

TIMED_WAITING 线程在等待唤醒，但设置了时限

TERMINATED 这个状态下表示该线程的run方法已经执行完毕了, 基本上就等于死亡了(当时如果线程被持久持有, 可能不会被回收)

一、NEW

public static void main(String [] args){
	Thread thread = new Thread();
	System. out.println(thread.getState());
}

二、RUNNABLE

public static void RUNNABLE(){
	public void run(){
		while(true){
			System.out.println("Running...");
		}
	}
}

三、BLOCKED


public class BlockedTest {

    public static void main(String [] args){

        BLOCKED thd = new BLOCKED();
        Thread t1 = new Thread(thd);
        Thread t2 = new Thread(thd);
        t1.setName("MyThread #1");
        t2.setName("MyThread #2");

        t1.start();
        t2.start();
    }
}
class BLOCKED extends Thread {
    public void run(){
        synchronized (this){
            for (int i = 0; i < 2; i++){
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行的结果如下：

MyThread #1:0
MyThread #1:1
MyThread #1:2
MyThread #2:0
MyThread #2:1
MyThread #2:2

当两个并发线程(t1和t2)访问同一个对象(thd)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。t1和t2是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象

四、WAITING

这个需要用到生产者消费者模型, 当生产者生产过慢的时候, 消费者就会等待生产者的下一次notify

public class ProducerConsumerTest {
    public static void main(String [] args){

        CubbyHole c = new CubbyHole();
        Producer p1 = new Producer(c, 1);
        Consumer c1 = new Consumer(c, 1);
        p1.start();
        c1.start();
    }
}

class CubbyHole{
    private int contents;
    private boolean available = false;

    public synchronized int get(){
        while (available == false){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        available = false;
        notifyAll();
        return contents;
    }

    public synchronized void put(int value){
        while (available == true){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        contents = value;
        available = true;
        notifyAll();
    }
}

class Consumer extends Thread{
    private CubbyHole cubbyHole;
    private int number;

    public Consumer(CubbyHole c, int number){
        this.cubbyHole = c;
        this.number = number;
    }

    public void run(){
        int value;
        for (int i = 0; i < 10; i++){
            value = cubbyHole.get();
            System.out.println("消费者 #" + this.number + " got: " + value);
        }
    }
}

class Producer extends Thread{
    private CubbyHole cubbyHole;
    private int number;

    public Producer(CubbyHole c, int number){
        this.cubbyHole = c;
        this.number = number;
    }

    public void run(){
        for (int i = 0; i < 5; i++){
            cubbyHole.put(i);
            System.out.println("生产者 #" + this.number + " put: " + i );
//            try {
//                Thread.sleep((long) (Math.random() *  1000));
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
        }
    }
}

运行结果如下：

生产者 #1 put: 0
消费者 #1 got: 0
消费者 #1 got: 1
生产者 #1 put: 1
消费者 #1 got: 2
生产者 #1 put: 2
消费者 #1 got: 3
生产者 #1 put: 3
生产者 #1 put: 4
消费者 #1 got: 4

五、TIMED_WAITING

这个仅需要在四的基础上, 把注释里的代码添加进去就行了

public synchronized void put(int value){
        while (available == true){
            try {
                wait(10 * 100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        contents = value;
        available = true;
        notifyAll();
    }

或者在wait方法加上一个时间参数。

public void run(){
    for (int i = 0; i < 5; i++){
        cubbyHole.put(i);
        System.out.println("生产者 #" + this.number + " put: " + i );
        try {
            Thread.sleep((long) (Math.random() *  1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

六、TERMINATED
这个状态只要线程结束了run方法, 就会进入

public class TERMINATED {

    public static void main(String [] args){

        Thread t1 = new Thread();
        t1.start();
        System. out.println(t1.getState());
        try {
            Thread. sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System. out.println(t1.getState());
    }
}

运行结果：

RUNNABLE
TERMINATED