Java学习笔记2-线程的运行方式

Java学习笔记2-线程的运行方式

线程的6种状态

6个状态定义：java.lang.Thread.State

1. New：尚未启动的线程的线程状态。

2. Runnable：可运行线程的线程状态，等待CPU调度。

3. Blocked：线程阻塞等待监视器锁定的线程状态。

   处于synchronized同步代码块或方法中被阻塞。

4. Waiting：等待线程的线程状态。下列不带超时的方式：

   Object.wait、Thread.join、LockSupport.park

5. Timed Waiting：具有指定等待时间的等待线程的线程状态。下列带超时的方式：

   Thread.sleep、Object.wait、Thread.join、LockSupport.parkNanos、LockSupport.parkUntil

6. Terminated：终止线程的线程状态。线程正常完成执行或者出现异常。

线程的运行方式

1. New新线程 --开始–> 2

2. Runnable可运行状态 --等待锁–> 3

   ​ --等待其他线程的通知–> 4

   ​ --有超时时间的等待其他线程的通知–> 5

   ​ --执行结束–> 6

3. Blocked阻塞状态 --已拿到锁–> 2

4. Waiting等待状态 --收到通知，继续执行–> 2

5. Timed Waiting定时等待 --等待超时或者收到通知，继续执行–> 2

6. Terminated终止

线程的中止方式

1. 不推荐使用Thread.stop() 中止，线程不安全

2. 推荐使用Thread.interrupt() 中止，线程安全且会抛出InterruptedException方便控制

3. 也可线程内部使用while(flag)标志位控制线程中止

线程状态测试代码

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/7 19:35
 * @Modified By：
 */
public class DemoTest {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("线程1当前状态2：" + Thread.currentThread().getState());
        });
        System.out.println("线程1当前状态1：" + t1.getState());
        t1.start();
        Thread.sleep(200L);
        System.out.println("线程1当前状态3：" + t1.getState());

        Thread t2 = new Thread(() -> {
            try {
                System.out.println("线程2当前状态2：" + Thread.currentThread().getState());
                Thread.sleep(200L);
                System.out.println("线程2当前状态4：" + Thread.currentThread().getState());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("线程2当前状态1：" + t2.getState());
        t2.start();
        Thread.sleep(100L);
        System.out.println("线程2当前状态3：" + t2.getState());
        Thread.sleep(200L);
        System.out.println("线程2当前状态5：" + t2.getState());

        Thread t3 = new Thread(() -> {
            synchronized (DemoTest.class) {
                System.out.println("线程3当前状态4：" + Thread.currentThread().getState());
            }
        });
        synchronized (DemoTest.class) {
            System.out.println("线程3当前状态1：" + t3.getState());
            t3.start();
            System.out.println("线程3当前状态2：" + t3.getState());
            Thread.sleep(200L);
            System.out.println("线程3当前状态3：" + t3.getState());
        }
        Thread.sleep(200L);
        System.out.println("线程3当前状态5：" + t3.getState());

        Object obj = new Object();
        Thread t4 = new Thread(() -> {
            try {
                synchronized (obj) {
                    System.out.println("线程4当前状态2：" + Thread.currentThread().getState());
                    obj.wait();
                    System.out.println("线程4当前状态4：" + Thread.currentThread().getState());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("线程4当前状态1：" + t4.getState());
        t4.start();
        Thread.sleep(100L);
        System.out.println("线程4当前状态3：" + t4.getState());
        synchronized (obj) {
            obj.notify();
        }
        Thread.sleep(200L);
        System.out.println("线程4当前状态5：" + t4.getState());
    }
}