线程的状态

对于进程来说，核心状态有 就绪态 和 阻塞态。那么对于线程来说，也同样有 就绪态和阻塞态。线程除了这两种状态，还有其他六种状态，分别为：

 NEW：线程的对象已经存在，但线程还未被创建，即start()方法还没调用。

TERMINATED：线程的对象还在，但内核中线程已经没了。

RUNNABLE：就绪态，表示线程处于 运行中 或 正等待去CPU上去执行。

TIMED_WATING：阻塞态，由于sleep这种固定时间方式所产生的阻塞。

BLOCKED：阻塞态，由于锁竞争所产生的阻塞。

WAITING：阻塞态，由于wait这种无固定时间方式所产生的阻塞。

可以通过代码来获取到当前线程的状态，NEW状态代码如下：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{

        });
        t1.join();
        System.out.println(t1.getState());
    }
}

当前t1线程的对象已经存在，但是t1线程还未被创建，因此获取到当前t1线程的状态是NEW状态。

RUNNABLE状态代码如下：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
           while (true){
               
           }
        });
        System.out.println(t1.getState());
        t1.start();
        System.out.println(t1.getState());
    }
}

start(）方法调用之前，t1线程是NEW状态，start()方法调用之后，t1线程是RUNNABLE状态，说明此时t1线程是运行态或正等待去CPU上执行。

TERMINATED状态代码如下：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{

        });
        System.out.println(t1.getState());
        t1.start();
        t1.join();
        System.out.println(t1.getState());
    }
}

 

start(）方法调用之前，t1线程是NEW状态，start()方法调用之后，等待t1线程执行结束后再获取t1线程的状态是TERMINATED状态，说明此时内核中t1线程已经没了，但t1线程的对象还在。

TIMED_WAITING状态代码如下：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(t1.getState());
            Thread.sleep(1000);
        }
    }
}

 

每次获取t1线程状态时，t1线程时而在运行态，时而由于sleep(）处于阻塞态。

BLOCKED状态代码如下：

public class Demo {
    public static Object locker = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (locker){
                for (int i = 0; i < 2; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("t1拿到锁！");
                }
            }

        });
        Thread t2 = new Thread(()->{
            synchronized (locker){
                for (int i = 0; i < 1; i++) {
                    System.out.println("t2拿到锁！");
                }
            }
        });
        t1.start();
        t2.start();
        Thread.sleep(1000);
        for (int i = 0; i < 2; i++) {
            System.out.println(t2.getState());
        }
    }
}

 

先让t1，t2线程都开始去执行，且两个线程会竞争同一把锁，让t1线程先拿到锁，再让t2去拿锁，由于此时锁已经被t1线程拿到了且还没有释放，t2线程陷入阻塞状态，输出的是BLOCKED。