Java多线程~线程的状态以及状态转移的条件

目录

线程的六种状态

状态转移的条件

NEW

RUNNABLE

BLOCKED

WAITING

TIMED_WAITING

TERMINATED

---

线程的六种状态

线程共有六种状态，分别为：

· NEW(初始状态)：new表示新建一个线程对象，即安排了工作，但未开始行动

· RUNNABLE(可运行态)：表示一个线程在等待被调度或者正在运行中，可以说成是正在工作中和即将开始工作

· BLOCKED(阻塞状态)：表示一个线程阻塞在进入synchronized修饰的方法或代码块时的状态，即排队等着其他事情

· WAITING(等待状态)：表示一个线程需要等待其他线程做出一些特殊的动作(中断或者通知)，其作用是让出CPU，等待被显示的唤醒，被唤醒后进入BLOCKED状态，再重新获取锁

· TIMED_WAITING(超时等待)：与WAITING一样，但不同的是超时等待，在一定时间内让出CPU，时间到了后自动唤醒，进入BLOCKED状态，再重新获取锁，WAITING是无限期等待

· TERMINATED(终止状态)：表示线程已经执行完毕，退出的线程处于该状态

状态转移的条件

NEW

新建立的线程在没有调用start方法之前处于这个状态

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {}
            }
        },"t线程");
    }
}

例如上述代码，创建了线程t，但是未调用start方法，此时线程t就处于NEW初始状态

RUNNABLE

在NEW状态的线程调用start方法之后，转换为RUNNABLE状态，另外正在CPU上运行/即将准备运行的线程也处于RUNNABLE状态

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {}
            }
        },"t线程");
        t.start();
    }
}

上述t线程调用了start方法后，即进入了运行状态，可以通过jconsole进行观察

  

BLOCKED

当前线程在申请synchronized锁时，如果该锁此时正在被其他线程占用，就会进入阻塞状态

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    while(true) {}
                }
            }
        },"t线程");
        t.start();
        Thread.sleep(100);
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    while(true) {}
                }
            }
        },"t1线程");
        t1.start();
    }
}

 上述代码创建了两个线程，t和t1，t线程先申请synchronized锁，申请成功后占有该锁，此时t1线程再进行申请时，此时锁被t线程占用，t1线程就会进入BLOCKED等待状态，通过jconsole观察如下

WAITING

调用wait方法后会进入等待状态

public class Test {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    synchronized (lock) {
                        lock.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t线程");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    while (true) {}
                }
            }
        },"t1线程");
        t.start();
        t1.start();
    }
}

例如上述代码，启动t和t1线程后，当t线程申请到锁后就调用wait方法进入WAITING等待状态，等待被唤醒

 

TIMED_WAITING

调用sleep方法或wait(超时时间)后会进入该状态

public class Test {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    synchronized (lock) {
                        while(true) {
                            lock.wait(100);
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t线程");
        t.start();
    }
}

t线程启动后，一直循环调用wait方法，使线程t一直处于TIMED_WAITING超时等待状态，如果未使用while语句一直循环，则当休眠0.1s后，就自动被唤醒，进入BLOCKED状态，再重新申请获取锁 

 

 

TERMINATED

当一个线程执行完毕后，就处于该状态了

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t线程此时的状态为: " + Thread.currentThread().getState());
            }
        });
        t.start();
        t.join();//main线程等待t线程执行完之后再执行
        System.out.println("t线程此时的状态为: " + t.getState());
    }
}