Java多线程-线程的创建(Thread类的基本使用)

待我称王封你为后i 2023-09-25 14:14 81阅读 0赞

#### 文章目录 ####

*  一. 线程和Thread类
 *   *  1. 线程和Thread类
     *   *  1.1 Thread类的构造方法
         *  1.2 启用线程的相关方法
     *  2. 创建第一个Java多线程程序
     *  3. 使用Runnable对象创建线程
     *  4. 使用内部类创建线程
     *  5. 使用Lambada表达式创建线程
     *  6. 多线程并发执行简单演示
     *  7. 多线程并发执行的优势
 *  二. Thread类的属性与方法
 *   *  1. Thread类中的重要属性
     *  2. Thread类中常用方法总结
     *   *  2.1 常用方法
         *  2.2 中断线程
         *  2.3 线程等待
         *  2.4 线程调用start和直接调用run的区别
 *  三. Java线程的状态
 *   *  1. Java线程中的基本状态
     *  2. 线程的状态转移

在Java中如何进行多线程编程呢?  
关于线程的操作, 操作系统是提供了一系列的API的, 而Java是一个跨平台的语言, 很多操作系统提供的功能都是被JVM封装好了的, 所以用Java进行多线程编程, 只需要学习Java提供的API即可, Java中进行多线程操作主要是 `Thread`类.

## 一. 线程和Thread类 ##

### 1. 线程和Thread类 ###

线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对用户层提供了一些 API 供用户使用(例如 Linux 的 pthread 库).

Java 标准库中 `Thread` 类可以视为是对操作系统提供的 API 进行了进一步的抽象和封装.

也就是说在Java中`Thread`类的实例就对应着一个线程.

#### 1.1 Thread类的构造方法 ####

<table> 
 <thead> 
  <tr> 
   <th><strong>方法</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public Thread()</td> 
   <td>无参数构造方法</td> 
  </tr> 
  <tr> 
   <td>public Thread(String name)</td> 
   <td>指定线程名创建线程</td> 
  </tr> 
  <tr> 
   <td>public Thread(Runnable target)</td> 
   <td>传入实现Runnable接口的对象 (任务对象) 构造线程</td> 
  </tr> 
  <tr> 
   <td>public Thread(Runnable target, String name)</td> 
   <td>根据目标任务并指定线程名创建线程</td> 
  </tr> 
  <tr> 
   <td>public Thread(ThreadGroup group, Runnable target)</td> 
   <td>根据线程组和任务创建线程(了解)</td> 
  </tr> 
  <tr> 
   <td>public Thread(ThreadGroup group, Runnable target, String name)</td> 
   <td>根据线程组和任务创建线程并指定线程名</td> 
  </tr> 
 </tbody> 
</table>

#### 1.2 启用线程的相关方法 ####

<table> 
 <thead> 
  <tr> 
   <th><strong>方法</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void run()</td> 
   <td>用来封装线程运行时执行的内容, 线程线程创建时必须重写run方法</td> 
  </tr> 
  <tr> 
   <td>public synchronized void start()</td> 
   <td>线程创建并执行run方法</td> 
  </tr> 
  <tr> 
   <td>public static native void sleep(long millis) throws InterruptedException</td> 
   <td>使线程休眠millis毫秒</td> 
  </tr> 
 </tbody> 
</table>

### 2. 创建第一个Java多线程程序 ###

我们这里创建一个`MyThread`类并继承`Thread`类, 然后重写`run`方法.

class MyThread extends Thread{
        
        //重写run方法
        @Override
        public void run() {
        
            System.out.println("hello thread");
        }
    }
    public class TestDemo {
        
        public static void main(String[] args) {
        
            //创建MyThread线程对象,注意此时并没有创建线程
            Thread thread = new MyThread();
            //线程创建并运行
            thread.start();
        }
    }

注意:

上面的代码中, 使用`new`创建线程对象, 此时仅仅是创建了一个线程对象, 并没有去创建线程, 当线程对象去调用`start`方法时才会创建线程并执行线程任务也就是`run`方法.

执行结果:

![img][]

### 3. 使用Runnable对象创建线程 ###

上面介绍的是使用子类继承`Thread`并重写`run`方法来创建线程, 除了这种方法还可以使用`Runnable`接口, 这个接口也有一个`run`方法, 这个`Runnable`对象可以理解成"任务", 可以将这个任务交给`Thread`对象去进行构造, 然后执行任务(执行`run`方法).

同样的, `Runnable`是一个接口, 子类实现了该接口后, 需要重写`run`方法, 线程`Thread`对象构造好后, 此时线程还没有创建, 调用start对象来创建线程并执行即可.

class MyRunnable implements Runnable {
        
        @Override
        public void run() {
        
            System.out.println("使用Runnable描述任务!");
        }
    }
    
    public class TestDemo1 {
        
        public static void main(String[] args) {
        
            //创建Runnable任务传给Thread对象来进行构造
            Runnable runnable = new MyRunnable();
            Thread thread = new Thread(runnable);
            //启动线程
            thread.start();
        }
    }

执行结果:  
![img][img 1]

这种写法相较于上面的写法让线程和和线程要干的活分离开来, 相较于上面就是在解耦合了, 这种写法更符合 “高内聚, 低耦合的编程风格”, 也是更推荐的写法.

### 4. 使用内部类创建线程 ###

针对上面的2和3, 我们可以写的更简洁一些, 使用匿名内部类来传入匿名对象来重写`run`方法.

public class TestDemo2 {
        
        public static void main(String[] args) {
        
            Thread thread = new Thread() {
        
                @Override
                public void run() {
        
                    System.out.println("使用匿名内部类创建线程匿名对象!");
                }
            };
            thread.start();
        }
    }

执行结果:

![img][img 2]

public class TestDemo3 {
        
        public static void main(String[] args) {
        
            Thread t = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("使用匿名内部类创建线程匿名对象(1)!");
                }
            });
            t.start();
        }
    }

执行结果:

![img][img 3]

### 5. 使用Lambada表达式创建线程 ###

针对上面的3还可以进行简写, 写成lambada表达式的形式, 本质还是使用匿名内部类创建的`Thread.`

public class TestDemo4 {
        
        public static void main(String[] args) {
        
            Thread thread = new Thread(() -> 
                    System.out.println("使用lambda表达式来创建线程!"));
            thread.start();
        }
    }

执行结果:

![img][img 4]

### 6. 多线程并发执行简单演示 ###

一个代码程序中有一个`main`方法, 这里其实有一个`main`线程(主线程, 这个线程是程序运行时自动创建的), 在一个进程中至少会有一个线程, 如果不使用多线程编程, 一个进程中默认执行的就是这个`main`线程.

而如果我们再在main中创建一个新线程`t`并调用, 这个线程t会与`mian`线程并发执行.

public class TestDemo5 {
        
        public static void main(String[] args) {
        
            //thread 线程
            Thread thread = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    for (int i = 0; i < 10; i++) {
        
                        System.out.println("thread线程执行中!");
                        //为了让这里的打印慢一点使效果更加明显,可以使用sleep方法设定线程睡眠时间
                        try {
        
                            Thread.sleep(1000);//每执行一次循环就睡眠1秒
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            });
            thread.start();
    
            //main 线程
            for (int i = 0; i < 10; i++) {
        
                System.out.println("main线程执行中!");
                //为了使效果更加明显,可以使用sleep方法设定线程睡眠时间
                try {
        
                    Thread.sleep(1000);//每执行一次循环就睡眠1秒
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

执行结果:

![img][img 5]

观察上面的运行结果, 可以发现结果中thread线程和main线程打印顺序是不固定的( “随机” 的), 这个问题有些时候会给我们带来很多麻烦(比如线程安全问题), 属于是Java多线程中的一个 “万恶之源” 了, 也就是说, 这里两个线程的执行顺序完全是随机的, 我们是没有办法去预测和设置的.

这里究其更本在于操作系统调度线程的时候, 线程是 “抢占式执行” 的, 具体哪个线程先执行, 哪个线程后执行是不确定的, 取决于操作系统调度器的具体实现策略.

注意这里的随机只是我们肉眼所看到的是随机的, 内核中线程的执行并不是随机的, 是有优先级的, 但是干预因素太多, 应用程序层面上我们也无法感知到细节也无法修改, 从应用程序(代码)的角度看到的效果, 就好像是线程之间的调度顺序是"随机"的一样, 我们也只能认为是随机的了.

### 7. 多线程并发执行的优势 ###

假设当前有两个变量, 需要把两个变量各自自增 1000w 次(**典型的 CPU 密集型的场景**), 可以一个线程, 先针对 `a` 自增, 然后再针对 `b` 自增; 还可以两个线程, 分别对 `a` 和 `b` 自增; 我们来看看使用两个线程和单独使用一个线程分别所需的时间是多少.

public class TestDemo6 {
        
        public static void main(String[] args) {
        
            //多线程
            concurrency();
            //单线程
            serial();
        }
    
        // 串行执行, 一个线程完成
        public static void serial() {
        
            // currentTimeMillis 获取到当前系统的 ms 级时间戳.
            long beg = System.currentTimeMillis();
    
            long a = 0;
            for (long i = 0; i < 100_0000_0000L; i++) {
        
                a++;
            }
            long b = 0;
            for (long i = 0; i < 100_0000_0000L; i++) {
        
                b++;
            }
    
            long end = System.currentTimeMillis();
            System.out.println("单线程执行时间: " + (end - beg) + " ms");
        }
    
        public static void concurrency() {
        
            // 使用两个线程分别完成自增.
            Thread t1 = new Thread(() -> {
        
                long a = 0;
                for(long i = 0; i < 100_0000_0000L; i++) {
        
                    a++;
                }
            });
            Thread t2 = new Thread(() -> {
        
                long b = 0;
                for(long i = 0; i < 100_0000_0000L; i++) {
        
                    b++;
                }
            });
            // 记录开始执行的时间戳
            long beg = System.currentTimeMillis();
            t1.start();
            t2.start();
    
            try {
        
                // 等待两个线程结束后,再获取结束时的时间戳
                t1.join();
                t2.join();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            // 获取执行结束时的时间戳
            long end = System.currentTimeMillis();
            System.out.println("多线程执行时间: " + (end - beg) + " ms");
        }
    }

执行结果:

![img][img 6]

根据结果此时两个线程并发执行的时间要单线程执行的时间快很多的, 此时多线程并发就可以提高程序整体的运行效率, 多线程比单线程执行的时间缩短并不是刚好一般的关系, 这是因为多线程能够更充分的利用到多核心cpu的资源, 但是此处我们并不是保证`t1和t2`是并行执行, 而不是并发执行.

那么多线程并发执行是否一定就优于单线程呢, 其实不然, 如果任务量不够大, 可能多线程相比于单线程并不会有优势, 毕竟创建线程本身还是有开销的; 还有如果在同一进程中一味的增加线程的数量, 也不是一直可以提高运行速度, 要知道我们电脑中CPU核心数量是有限的, 当线程太多, 核心数目有限, 不少的开销反而浪费在了线程调度上, 可能就没办法高效执行任务了.

**多线程在IO密集型的任务中, 也是有作用的**, 日常使用一些程序,经常会看到"程序未响应", 这是因为程序进行了一些耗时的IO操作(比如一些程序启动要加载数据文件,就涉及到大量的读硬盘操作), 阻塞了界面的响应, 这种情况下使用多线程也是可以有效改善的(让一个线程负责IO, 另一个线程用来响应用户的操作).

## 二. Thread类的属性与方法 ##

### 1. Thread类中的重要属性 ###

<table> 
 <thead> 
  <tr> 
   <th><strong>属性</strong></th> 
   <th><strong>获取该属性的方法</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>线程的标识(ID)</td> 
   <td>public long getId()</td> 
  </tr> 
  <tr> 
   <td>线程的名称</td> 
   <td>public final String getName()</td> 
  </tr> 
  <tr> 
   <td>线程的状态</td> 
   <td>public State getState()</td> 
  </tr> 
  <tr> 
   <td>线程的优先级</td> 
   <td>public final int getPriority()</td> 
  </tr> 
  <tr> 
   <td>线程是否是后台(守护)线程</td> 
   <td>public final boolean isDaemon()</td> 
  </tr> 
  <tr> 
   <td>线程是否存活</td> 
   <td>public final native boolean isAlive()</td> 
  </tr> 
  <tr> 
   <td>线程是被中断</td> 
   <td>public boolean isInterrupted()</td> 
  </tr> 
 </tbody> 
</table>

每一个线程都有一个`id`作为标识, 但并不是每个线程都有唯一的`id`, 只有处于同一进程的线程`id`才是相同的, 唯一标识的的说法按进程说才是正确的, 每个进程都拥有唯一的`id`标识.

上面说过, 线程的名字我们可以通过构造方法手动去设置, 但如果我们创建`Thread`对象时, 没有指定线程对象的名称, 则会默认命名为`Thread-i`, 其中`i`为整数.

同样的, Java中的线程的状态也有运行, 阻塞, 就绪`3`种状态, 每个线程也有优先级.

Java当中线程分为前台线程和后台线程(也叫守护线程), 其中后台线程不会影响进程的退出, 而前台线程会影响进程的退出, 比如同一进程内有`t`和`main`(主线程)两个线程, 当`t`为前台线程, `main`方法执行完毕时, 如果此时`t`线程还没有执行完, 那么`t`线程会继续执行, 进程等到`t`线程执行结束后才会退出; 反之, 如果`t`线程为后台线程, `main`方法执行完毕, 此时`t`线程没有执行完也会被强制结束, 也就是是说此时`main`结束后, 整个进程就随之结束了; 我们代码里手动创建的线程(包括main线程)默认都是前台的, 其他JVM自带的线程都是后台的, 我们可以手动使用`setDaemon`将线程设置为后台线程.

关于java线程的属性, 我们可以通过java官方的`jconsole`调试工具查看java线程的一些属性, 这个工具一般在`jdk`的`bin`目录下.

![img][img 7]

双击打开出现如下界面, 选择需要查看的进程连接查看:

![img][img 8]

![img][img 9]

选择需要查看的进程属性查看：

![img][img 10]

### 2. Thread类中常用方法总结 ###

#### 2.1 常用方法 ####

<table> 
 <thead> 
  <tr> 
   <th><strong>方法</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void run()</td> 
   <td>该方法用来封装线程运行时执行的内容</td> 
  </tr> 
  <tr> 
   <td>public synchronized void start()</td> 
   <td>线程创建并执行run方法</td> 
  </tr> 
  <tr> 
   <td>public static native void sleep(long millis) throws InterruptedException</td> 
   <td>使线程休眠millis毫秒</td> 
  </tr> 
  <tr> 
   <td>public final void join() throws InterruptedException</td> 
   <td>等待线程结束</td> 
  </tr> 
  <tr> 
   <td>public final synchronized void join(long millis) throws InterruptedException</td> 
   <td>等待线程结束, 最多等待millis毫秒</td> 
  </tr> 
  <tr> 
   <td>public final synchronized void join(long millis, int nanos) throws InterruptedException</td> 
   <td>指定最多等待时间等待线程, 精确到纳秒</td> 
  </tr> 
  <tr> 
   <td>public void interrupt()</td> 
   <td>中断线程, 修改中断标志位状态为true, 如果线程在休眠(阻塞状态)会抛出异常通知, 同时再将标志位设置回false</td> 
  </tr> 
  <tr> 
   <td>public static boolean interrupted()</td> 
   <td>判断当前线程的中断标志位是否设置, 调用后会清除线程的中断标志位</td> 
  </tr> 
  <tr> 
   <td>public boolean isInterrupted()</td> 
   <td>判断当前线程的中断标志位是否设置, 调用后不会影响线程的标志位</td> 
  </tr> 
  <tr> 
   <td>public final synchronized void setName(String name)</td> 
   <td>修改线程对象名称</td> 
  </tr> 
  <tr> 
   <td>public static native Thread currentThread()</td> 
   <td>获取当前线程对象</td> 
  </tr> 
 </tbody> 
</table>

#### 2.2 中断线程 ####

首先要理解好这里中断的意思, 这里的中断, 不是让线程立即停止, 而是通知线程, 你应该要停止了, 至于是否真的停止, 取决于线程代码的具体写法.

*  **方式1: 自己设置一个标志位来来控制线程是否要停止**

如果我们想中断一个正在执行的线程, 该如何做呢？

最简单方法就是我们在`run`方法中定义一个中断标志位(有`true`和`false`两种状态), 每次执行具体任务时需要先判断中断标志位的状态, 如果是`false`就结束线程, 为`true`继续执行.

public class TestDemo7 {
        
        private static boolean flag = true;
    
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(() -> {
        
                while (flag) {
        
                    System.out.println("hello thread");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
            t.start();
    
            Thread.sleep(3000);
            // 在主线程里就可以随时通过 flag 变量的取值, 来操作 t 线程是否结束.
            flag = false;
        }
    }

执行结果:

![img][img 11]

这个代码是否能够起到通过修改`flag`就让`t`线程就结束, 完全取决于`t`线程内部代码的写法, 代码里通过flag 来控制循环; 因此, 这里`flag = false`只是告诉让这个线程结束, 这个线程是否要结束, 啥时候结束都是线程内部自己代码来决定的.

但这种方法是不够严谨的, 有些时候是不能达到我们想要的效果的, 比如当`main`线程中设置`flag`为`false`时, 而`t`线程在此时休眠状态, 此时`t`线程只有在休眠结束后才能中断, 这种情况下线程`t`就不能及时的做出响应进行中断, 而我们期望的是`flag`的值设置为`false`时, `t`线程可以立即中断.

*  **方式2: 使用Thread类中自带标志位**

首先使用`currentThread`方法获取线程对象, 然后再调用该对象中的`isterrupted`方法获取该对象的中断标志位代替我们上面所写的`flag`标志位, 然后等该线程运行一段时间后使用`interrupt`方法改变标志位, 中断线程, 写出如下代码观察效果:

public class TestdDemo8 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(() -> {
        
                while (!Thread.currentThread().isInterrupted()) {
        
                    System.out.println("hello thread");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
            t.start();
            Thread.sleep(3000);
    
            t.interrupt();
        }
    }

执行结果:

![img][img 12]

观察上面的执行结果, 发现`t`线程并没有按照我们所预期的中断, 在抛出一个`InterruptedException`异常后, 线程`t`又继续执行了, 原因时`interrupt`方法遇到因为调用 `wait/join/sleep` 等方法而阻塞的线程时会使这些方法抛出异常, 并且清空标志位(设置回`false`), 这时我们的catch语句里面值输出了异常信息并没有去中断异常, `sleep`清空标志位的目的在于, 将线程从休眠状态唤醒之后, 线程是否要终止, 还是要过一会儿再终止, 选则权就交给程序员自己了.

那么如何解决呢? 很简单, 所以我们需要在catch语句中加上线程让线程退出的break语句即可.

public class TestdDemo8 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(() -> {
        
                while (!Thread.currentThread().isInterrupted()) {
        
                    System.out.println("hello thread");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                        break;
                    }
                }
            });
            t.start();
            Thread.sleep(3000);
    
            t.interrupt();
        }
    }

执行结果:

![img][img 13]

除了`isInterrupted`, 还有一个静态方法`interrupted`能够访问中的标志位, 我们也可以使用该静态方法来作为中断标志位, 仍然使用`interrupt`方法来中断线程执行.

public class TestDemo9 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(() -> {
        
                while (!Thread.interrupted()) {
        
                    System.out.println("hello thread");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                        break;
                    }
                }
            });
            t.start();
            Thread.sleep(3000);
    
            t.interrupt();
        }
    }

执行结果:

![img][img 14]

#### 2.3 线程等待 ####

线程是一个随机调度的过程, 线程等待要做的事情就是控制两个线程结束的顺序.

上面演示多线程并发执行的优势的代码中就使用了`join`进行了线程等待, `main`线程需要等到t1和t2两个线程执行结束后才能执行后面的代码操作.

这里需要理解的是, 使用了`join`方法是进行线程等待, 那么是谁等谁呢?

其实也好理解, 假设有`A`和`B`两个线程, 线程`A`当中调用了`B.join()`方法, 那么此时线程A表示调用`join`方法的线程, 线程B表示`join`方法来自B线程对象, 这种情况下就是`A`线程等待`B`线程结束.

`join`的无参数版本是一个 “死等” 的方法, 还是上面的例子, 如果`B`线程中出现了bug, 导致`B`线程不能结束, 此时`A`线程也就不能正常执行了, 程序就僵住了, 所以为了防止这种死等情况的出现, `join`方法还有带参数的版本, 可以指定最长等待时间.

public class TestDemo10 {
        
        public static void main(String[] args) {
        
            Thread t = new Thread(() -> {
        
                for (int i = 0; i < 3; i++) {
        
                    System.out.println("hello thread");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
            t.start();
            // 此处的 join 就是让当前的 main 线程来等待 t 线程执行结束 (等待 t 的 run 执行完)
            try {
        
                t.join();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("t线程执行完之后再执行这里!");
        }
    }

执行结果:

![img][img 15]

#### 2.4 线程调用start和直接调用run的区别 ####

通过上面的内容, 我们知道执行一个线程的任务就是执行线程对象中重写的`run`方法, 那么我们是否可以直接调用`run`方法来代替`start`方法呢?

答案是不行的, 这两种调用方式是有本质区别的, 直接通过线程对象调用`run`方法就是单纯地调用了`Thread`对象中的一个普通方法而已, 并没有创建一个新线程来执行`run`方法, 而是通过`main`线程来执行的`run`方法, 而使用`start`方法, 会创建一个新线程并执行`run`方法.

## 三. Java线程的状态 ##

### 1. Java线程中的基本状态 ###

操作系统中进程的状态有三种分别为阻塞, 就绪和执行, 而java线程中的状态基本上相同, 只是区分的更加细节, 具体如下:

`NEW`: 安排了工作, 还未开始行动, 就是创建了Thread对象, 但还没有执行start方法(内核里面还没有创建对应PCB), 这个状态是java内部的状态, 与操作系统中线程的状态没有关联.

`RUNNABLE`: 可工作的, 又可以分成正在工作中和即将开始工作(即正在CPU上执行的任务或者在就绪队列里随时可以去CPU上执行的).

`BLOCKED`: 线程正在等待锁释放而引起的阻塞状态(synchronized加锁).

`WAITING`: 线程正在等待等待唤醒而引起的阻塞状态(waitf方法使线程等待唤醒).

`TIMED_WAITING`: 在一段时间内处于阻塞状态, 通常是使用sleep或者join(带参数)方法引起.

`TERMINATED`:Thread对象还存在, 但是关联的线程已经工作完成了, 这个状态也是java内部的状态, 与操作系统中线程的状态没有关联.

线程的状态其实是一个枚举类型:`Thread.State`

![img][img 16]

我们通过遍历来看一下这个枚举有哪些状态:

public class Test {
        
        public static void main(String[] args) {
        
            for(Thread.State state : Thread.State.values()) {
        
                System.out.println(state);
            }
        }
    }

执行结果:

![img][img 17]

我们知道操作系统内核中线程是通过一个PBC结构体来描述的, 多个线程是通过链表连在一起的, 但要注意这些线程不一定是在一个链表里, 具体在哪个链表跟线程的状态有关, 内核中有就绪队列和阻塞队列两个队列, 操作系统每次需要调度一个线程去执行就是从就绪队列中选一个节点去执行, 当线程进入阻塞状态, 就会把这个线程从就绪队列中拎出来放到阻塞队列中, 阻塞队列中的线程都是阻塞状态, 暂时不参与CPU的调度执行, 但当这个线程从阻塞状态被唤醒回到就绪队列, 考虑到调度的开销, 唤醒之后不会被立即调度执行的.

比如调用线程Asleep(1000), 对应的线程PCB就要再阻塞队列中待1000ms这么久, 当这个PCB回到了就绪队列, 虽然是sleep(1000), 但是实际上考虑到调度的开销, 对应的线程是无法在唤醒之, 后立即就执行的.实际上的时间间隔大概率要大于1000ms.

### 2. 线程的状态转移 ###

![img][img 18]

简单演示一下:

public class TestDemo11 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(() -> {
        
                for (int i = 0; i < 100; i++) {
        
                    // 这个循环体啥都不干, 也不 sleep
                }
            });
            // 启动之前, 获取 t 的状态, 就是 NEW 状态.
            System.out.println("start之前的状态: "+t.getState());
            t.start();
            System.out.println("t执行中的状态: "+t.getState());
            t.join();
            // 线程执行完毕之后, 就是 TERMINATED 状态
            System.out.println("t结束之后的状态: "+t.getState());
        }
    }

执行结果:

![img][img 19]

当我们在t线程中加上sleep方法时, 我们看到的打印出来状态是`RUNNABLE`还是`TIME_WAITING`取决于我们t线程当时运行到了哪个环节, 即取决于系统里的调度操作, 获取状态这一瞬间线程是sleep, 还是正在执行.

public class TestDemo11 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(() -> {
        
                for (int i = 0; i < 100; i++) {
        
                    try {
        
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
            // 启动之前, 获取 t 的状态, 就是 NEW 状态.
            System.out.println("start 之前: " + t.getState());
            t.start();
            for (int i = 0; i < 100; i++) {
        
                System.out.println("t 执行中的状态: " + t.getState());
            }
            t.join();
            // 线程执行完毕之后, 就是 TERMINATED 状态
            System.out.println("t 结束之后: " + t.getState());
        }
    }

执行结果:

![img][img 20]

获取的100次 t 执行中的状态中`RUNNABLE`的次数是要少于`TIMED_WAITING`的次数的, 这是因为相比于`t`在cpu上执行的时间来说, `sleep(10)`这个时间太长了; 要想让时间更均衡, 需要给t线程的run方法加入更多的计算逻辑.

`WAITING`和`BLOCKED`也类似, 只是触发条件不同, 一个是`wait`, `join`, 另一个是`synchronized`加锁等.

[img]: https://img-blog.csdnimg.cn/img_convert/9fc5303b2e2f57ec43b095055c9c22ae.png
[img 1]: https://img-blog.csdnimg.cn/img_convert/4e189c4c0f87ec5d304e1e405c3b4933.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/1c0a29cb0c35e044cb6d6f3374dc35b6.png
[img 3]: https://img-blog.csdnimg.cn/img_convert/b0915a2e08196dbf683e718302d9e1e6.png
[img 4]: https://img-blog.csdnimg.cn/img_convert/6f60827dedbfa399858e0027988770b9.png
[img 5]: https://img-blog.csdnimg.cn/img_convert/0937b1be01ead35905779a79cff43e02.png
[img 6]: https://img-blog.csdnimg.cn/img_convert/0e612f3684e8305138fc0c02db210bdc.png
[img 7]: https://img-blog.csdnimg.cn/img_convert/6b55294166a5a47e034eb50627de7e24.png
[img 8]: https://img-blog.csdnimg.cn/img_convert/d769fd44a71c0f3cabbf9ece609a6f3c.png
[img 9]: https://img-blog.csdnimg.cn/img_convert/5facc2779b18e6662cad888fd215b9d9.png
[img 10]: https://img-blog.csdnimg.cn/img_convert/40ee17788e509acf49c17e893c5ad550.png
[img 11]: https://img-blog.csdnimg.cn/img_convert/75b5d1cf02c8b66052dbcf811944ee6e.png
[img 12]: https://img-blog.csdnimg.cn/img_convert/fe18aee933afa15fbc5795777e24d537.png
[img 13]: https://img-blog.csdnimg.cn/img_convert/2cd229e24cc0d50cf6562e3669aab6f3.png
[img 14]: https://img-blog.csdnimg.cn/img_convert/7fbd1277ee3b81e5033e99ad58110980.png
[img 15]: https://img-blog.csdnimg.cn/img_convert/f24d40a6fece67118a7eb69f045f62cf.png
[img 16]: https://img-blog.csdnimg.cn/img_convert/08d230f0f49bb3b6624b2ccb680bd6d1.png
[img 17]: https://img-blog.csdnimg.cn/img_convert/2b0be273ff3475ca5983f361472d3fb0.png
[img 18]: https://img-blog.csdnimg.cn/img_convert/cd0ac792680b093cae248809e2e8c51f.png
[img 19]: https://img-blog.csdnimg.cn/img_convert/9f0f33912968c8e9514d68c693da6c94.png
[img 20]: https://img-blog.csdnimg.cn/img_convert/8a961da24ff80e3b1b3d48c10151d90a.png