Java 线程的六种状态

Scroll Down

相关概念

进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程中可以启动多个线程。

一个进程是一个独立的运行环境,它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中,并且可以共享进程中的资源。

多线程程序中,多个线程被并发的执行以提高程序的效率,CPU不会因为某个线程需要等待资源而进入空闲状态。多个线程共享堆内存(heap memory),因此创建多个线程去执行一些任务会比创建多个进程更好。举个例子,ServletsCGI 更好,是因为 Servlets 支持多线程而 CGI 不支持。

这里所谓的多个线程“同时”执行是人的感觉,实际上,是多个线程轮换执行。

线程调度器Thread Scheduler)是一个操作系统服务,它负责为Runnable状态的线程分配CPU时间。一旦我们创建一个线程并启动它,它的执行便依赖于线程调度器的实现。

时间片Time Slicing)是指将可用的CPU时间分配给可用的Runnable线程的过程。分配CPU时间可以基于线程优先级或者线程等待的时间。线程调度并不受到Java虚拟机控制,所以由应用程序来控制它是更好的选择(也就是说不要让你的程序依赖于线程的优先级)。

线程的6种状态

public enum State {

    NEW,

    RUNNABLE,

    BLOCKED,

    WAITING,

    TIMED_WAITING,

    TERMINATED;
}
  • NEW:只存在于线程刚创建,未调用start之前。
        MyThread myThread = new MyThread();
        System.out.println(myThread.getState());
  • RUNNABLE:正在 JVM 中执行,但是这个"执行",不一定是真的在运行, 也有可能是在等待CPU资源。所以,在网上,有人把这个状态区分为READYRUNNING两个,一个表示的start了,资源一到位随时可以执行,另一个表示真正的执行中,这取决于操作系统处理器。
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println(myThread.getState());
  • BLOCKED:线程等待获取一个锁,来继续执行下一步的操作,比较经典的就是synchronized关键字,这个关键字修饰的代码块或者方法,均需要获取到对应的锁,在未获取之前,其线程的状态就一直未BLOCKED,如果线程长时间处于这种状态下,我们就要当心是否会出现死锁的情况。
public class MyThreadTest {

    public static void main(String[] args) throws InterruptedException {
        byte[] lock = new byte[0];
        MyThread thread1 = new MyThread(lock);
        thread1.start();
        MyThread thread2 = new MyThread(lock);
        thread2.start();
        Thread.sleep(1000);//等一会再检查状态
        System.out.println(thread2.getState());
    }

}

class MyThread extends Thread {

    private byte[] lock = new byte[0];

    public MyThread(byte[] lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("done");

        }
    }
}
  • WAITING:等待状态。进入这个状态,一定是执行了如下的一些代码,例如

    • Object.wait()
    • Thread.join()
    • LockSupport.park()

    当一个线程执行了Object.wait()的时候,它一定在等待另一个线程执行Object.notify()或者Object.notifyAll()。或者一个线程thread,其在主线程中被执行了thread.join()的时候,主线程即会等待该线程执行完成。当一个线程执行了LockSupport.park()的时候,其在等待执行LockSupport.unpark(thread)。当该线程处于这种等待的时候,其状态即为WAITING。需要关注的是,这边的等待是没有时间限制的,当发现有这种状态的线程的时候,若其长时间处于这种状态,也需要关注下程序内部有无逻辑异常。

    LockSupport.park()

    public class MyThreadTest {
    
        public static void main(String[] args) throws InterruptedException {
            byte[] lock = new byte[0];
            MyThread thread1 = new MyThread(lock);
            thread1.start();
            Thread.sleep(100);
            System.out.println(thread1.getState());
            LockSupport.unpark(thread1);
            Thread.sleep(100);
            System.out.println(thread1.getState());
        }
    
    }
    
    class MyThread extends Thread {
    
        private byte[] lock = new byte[0];
    
        public MyThread(byte[] lock) {
            this.lock = lock;
        }
    
        @Override
        public void run() {
            LockSupport.park();
        }
    }
    

    Object.wait()

    public class MyThreadTest {
    
        public static void main(String[] args) throws InterruptedException {
            byte[] lock = new byte[0];
            MyThread thread1 = new MyThread(lock);
            thread1.start();
            Thread.sleep(100);
            System.out.println(thread1.getState()); //这时候线程状态应为WAITING
            synchronized (lock){
                lock.notify(); //notify通知wait的线程
            }
            Thread.sleep(100);
            System.out.println(thread1.getState());
        }
    
    }
    
    class MyThread extends Thread {
    
        private byte[] lock = new byte[0];
    
        public MyThread(byte[] lock) {
            this.lock = lock;
        }
    
        @Override
        public void run() {
            synchronized (lock){
                try {
                    lock.wait(); //wait并允许其他线程同步lock
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    Thread.join()

    public class MyThreadTest {
    
        public static void main(String[] args) throws InterruptedException {
                byte[] lock = new byte[0];
                MyThread1 thread1 = new MyThread1(lock);
                thread1.start();
                MyThread2 thread2 = new MyThread2(thread1);
                thread2.start();
                Thread.sleep(100);
                System.out.println(thread2.getState());
        }
    
    }
    
    class MyThread1 extends Thread {
    
        private byte[] lock = new byte[0];
    
        public MyThread1(byte[] lock) {
            this.lock = lock;
        }
    
        @Override
        public void run() {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    class MyThread2 extends Thread {
    
        Thread thread;
    
        public MyThread2(Thread thread) {
            this.thread = thread;
        }
    
        @Override
        public void run() {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
  • TIMED_WAITING:这个状态和WAITING状态的区别就是,这个状态的等待是有一定时效的,即可以理解为WAITING状态等待的时间是永久的,即必须等到某个条件符合才能继续往下走,否则线程不会被唤醒。但是TIMED_WAITING,等待一段时间之后,会唤醒线程去重新获取锁。当执行如下代码的时候,对应的线程会进入到TIMED_WAITING状态。

    • Thread.sleep(long)
    • Object.wait(long)
    • Thread.join(long)
    • LockSupport.parkNanos()
    • LockSupport.parkUntil()
  • TERMINATED:这个状态很好理解,即为线程执行结束之后的状态

线程的状态图

image.png