JAVA中五种线程状态的分析

Thred线程状态的分析
Java线程的生命周期中，存在几种状态。
新建状态：
NEW: 线程创建之后，但是还没有启动(not yet started)。这时候它的状态就是NEW

运行状态：
RUNNABLE: 正在Java虚拟机下跑任务的线程的状态。在RUNNABLE状态下的线程可能会处于等待状态，因为它正在等待一些系统资源的释放，比如IO

阻塞状态：
BLOCKED: 阻塞状态，等待锁的释放，比如线程A进入了一个synchronized方法，线程B也想进入这个方法，但是这个方法的锁已经被线程A获取了，这个时候线程B就处于BLOCKED状态
WAITING: 等待状态，处于等待状态的线程是由于执行了3个方法中的任意方法。
Object的wait方法，并且没有使用timeout参数;
Thread的join方法，没有使用timeout参数
LockSupport的park方法。处于waiting状态的线程会等待另外一个线程处理特殊的行为。
再举个例子，如果一个线程调用了一个对象的wait方法，那么这个线程就会处于waiting状态直到另外一个线程调用这个对象的notify或者notifyAll方法后才会解除这个状态

等待状态：
TIMED_WAITING: 有等待时间的等待状态，比如调用了以下几个方法中的任意方法，并且指定了等待时间，线程就会处于这个状态。

Thread.sleep方法
Object的wait方法，带有时间
Thread.join方法，带有时间
LockSupport的parkNanos方法，带有时间
LockSupport的parkUntil方法，带有时间

死亡状态：
TERMINATED: 线程中止的状态，这个线程已经完整地执行了它的任务

如果只是简单介绍上述的话，一半存在的都是面试的时候需要的，但如果想要深入理解，请看下方分析。
我们先说new新建状态
NEW状态比较简单，实例化一个线程之后，并且这个线程没有开始执行，这个时候的状态就是NEW：

Thread thread = new Thread();
System.out.println(thread.getState()); // NEW

在新建完成之后，线程调用run方法进入运行状态

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        for(int i = 0; i < Integer.MAX_VALUE; i ++) {
            System.out.println(i);
        }
    }
}, "run-Thred");
thread.start();

阻塞状态中也就是
线程A和线程B都需要持有lock对象的锁才能调用方法。如果线程A持有锁，那么线程B处于BLOCKED状态；如果线程B持有锁，那么线程A处于BLOCKED状态。例子中使用Thread.sleep方法主要是用于调试方便

final Object lock = new Object();
Thread threadA = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            System.out.println(Thread.currentThread().getName() + " invoke");
            try {
                Thread.sleep(20000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}, "线程a阻塞");
Thread threadB = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            System.out.println(Thread.currentThread().getName() + " invoke");
            try {
                Thread.sleep(20000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}, "线程b阻塞");
threadA.start();
threadB.start();

等待状态：
一般中我们最常用的就是wait方法，进入等待状态，wait是Object的方法，还有就是另外的两种Thread的join方法以及Conditon的await方法

final Object lock = new Object();
Thread threadA = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            try {
                lock.wait();
                System.out.println("wait over");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}, "WAITING-Thread-A");
Thread threadB = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            try {
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.notifyAll();
        }
    }
}, "WAITING-Thread-B");
threadA.start();
threadB.start();

Thread的join方法

hread threadA = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread-A over");
    }
}, "WAITING-Thread-A");
threadA.start();
try {
    threadA.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}

死亡状态：
线程在执行完成之后，会结束生命周期

Thread threadA = new Thread();
threadA.start();
try {
    Thread.sleep(5000l);
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.println(threadA.getState()); // TERMINATED

JAVA中五种线程状态的分析

猜你喜欢