线程的生命周期

线程的生命周期

线程进入阻塞的几种情况：=>对应解除的方式。[下面还有解释]

• sleep() => sleep()时间到
• 等待同步锁 => 获取同步锁
• wait()/join() => notify()/notifyAll()
• suspend() => resume()

yield()：线程让步，直接让当前线程进入阻塞状态。

sleep和wait的具体区别有：https://blog.csdn.net/qq_38998213/article/details/89503556

1，这两个方法来自不同的类分别是Thread（自控）和Object（他控）
2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
任何地方使用

  synchronized(x){
   x.notify()
   //或者wait()
  }

4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常（终端异常）

引用：https://www.cnblogs.com/sunddenly/p/4106562.html

线程生命周期

摘要：

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态。尤其是当线程启动以后，它不可能一直"霸占"着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换

\1. 新建状态，当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时仅由JVM为其分配内存，并初始化其成员变量的值

\2. 就绪状态，当线程对象调用了start()方法之后，该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器，等待调度运行

\3. 运行状态，如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态

\4. 阻塞状态，当处于运行状态的线程失去所占用资源之后，便进入阻塞状态

\5. 在线程的生命周期当中，线程的各种状态的转换过程

一、新建和就绪状态

当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的Java对象一样，仅仅由Java虚拟机为其分配内存，并初始化其成员变量的值。此时的线程对象没有表现出任何线程的动态特征，程序也不会执行线程的线程执行体。

当线程对象调用了start()方法之后，该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器，处于这个状态中的线程并没有开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。

注意：启动线程使用start()方法，而不是run()方法。永远不要调用线程对象的run()方法。调用start0方法来启动线程，系统会把该run()方法当成线程执行体来处理；但如果直按调用线程对象的run()方法，则run()方法立即就会被执行，而且在run()方法返回之前其他线程无法并发执行。也就是说，系统把线程对象当成一个普通对象，而run()方法也是一个普通方法，而不是线程执行体。需要指出的是，调用了线程的run()方法之后，该线程已经不再处于新建状态，不要再次调用线程对象的start()方法。只能对处于新建状态的线程调用start()方法，否则将引发IllegaIThreadStateExccption异常。

调用线程对象的start()方法之后，该线程立即进入就绪状态——就绪状态相当于"等待执行"，但该线程并未真正进入运行状态。如果希望调用子线程的start()方法后子线程立即开始执行，程序可以使用Thread.sleep(1) 来让当前运行的线程（主线程）睡眠1毫秒，1毫秒就够了，因为在这1毫秒内CPU不会空闲，它会去执行另一个处于就绪状态的线程，这样就可以让子线程立即开始执行。

二、运行和阻塞状态

2.1 线程调度

如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态，如果计算机只有一个CPU。那么在任何时刻只有一个线程处于运行状态，当然在一个多处理器的机器上，将会有多个线程并行执行；当线程数大于处理器数时，依然会存在多个线程在同一个CPU上轮换的现象。

当一个线程开始运行后，它不可能一直处于运行状态（除非它的线程执行体足够短，瞬间就执行结束了）。线程在运行过程中需要被中断，目的是使其他线程获得执行的机会，线程调度的细节取决于底层平台所采用的策略。对于采用抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务；当该时间段用完后，系统就会剥夺该线程所占用的资源，让其他线程获得执行的机会。在选择下一个线程时，系统会考虑线程的优先级。

所有现代的桌面和服务器操作系统都采用抢占式调度策略，但一些小型设备如手机则可能采用协作式调度策略，在这样的系统中，只有当一个线程调用了它的sleep()或yield()方法后才会放弃所占用的资源——也就是必须由该线程主动放弃所占用的资源。

2.2 线程阻塞**

当发生如下情况时，线程将会进入阻塞状态

① 线程调用sleep()方法主动放弃所占用的处理器资源

② 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞

③ 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。关于同步监视器的知识、后面将存更深入的介绍

④ 线程在等待某个通知（notify）

⑤ 程序调用了线程的suspend()方法将该线程挂起。但这个方法容易导致死锁，所以应该尽量避免使用该方法

当前正在执行的线程被阻塞之后，其他线程就可以获得执行的机会。被阻塞的线程会在合适的时候重新进入就绪状态，注意是就绪状态而不是运行状态。也就是说，被阻塞线程的阻塞解除后，必须重新等待线程调度器再次调度它。

2.3 解除阻塞**

针对上面几种情况，当发生如下特定的情况时可以解除上面的阻塞，让该线程重新进入就绪状态：

① 调用sleep()方法的线程经过了指定时间。

② 线程调用的阻塞式IO方法已经返回。

③ 线程成功地获得了试图取得的同步监视器。

④ 线程正在等待某个通知时，其他线程发出了个通知。

⑤ 处于挂起状态的线程被调甩了resdme()恢复方法。

图 2.1 线程状态转换图

从图2.1中可以看出，线程从阻塞状态只能进入就绪状态，无法直接进入运行状态。而就绪和运行状态之间的转换通常不受程序控制，而是由系统线程调度所决定。当处于就绪状态的线程获得处理器资源时，该线程进入运行状态；当处于运行状态的线程失去处理器资源时，该线程进入就绪状态。但有一个方法例外，调用yield()方法可以让运行状态的线程转入就绪状态。关于yield()方法后面有更详细的介纽。

三、线程死亡

3.1 死亡状态

线程会以如下3种方式结束，结束后就处于死亡状态：

① run()或call()方法执行完成，线程正常结束。

② 线程抛出一个未捕获的Exception或Error。

③ 直接调用该线程stop()方法来结束该线程——该方法容易导致死锁，通常不推荐使用。

3.2 程序设计

当主线程结束时，其他线程不受任何影响，并不会随之结束。一旦子线程启动起来后，它就拥有和主线程相同的地位，它不会受主线程的影响。为了测试某个线程是否已经死亡，可以调用线程对象的isAlivc()方法，当线程处于就绪、运行、阻塞了种状态时，该方法将返回true；当线程处于新建、死亡状态时，该方法将返回false。

不要试图对一个已经死亡的线程调用start()方法使它重新启动，死亡就是死亡，该线程将不可再次作为线程执行。

下面程序尝试对处于死亡状态的线程再次调用start()。

public class StartDead extends Thread {
    private int i;

    // 重写run方法，run方法的方法体就是线程执行体
    public void run() {
        for (; i < 100; i++) {
            System.out.println(getName() + "-" + i);
        }
    }

    public static void main(String[] args) {
        // 创建线程对象
        StartDead sd = new StartDead();
        for (int i = 0; i < 300; i++) {
            // 调用Thread的currentThread方法获取当前线程
            String name = Thread.currentThread().getName();
            System.out.println(name + "-" + i);
            if (i == 20) {
                // 启动线程
                sd.start();
                // 判断启动后线程的isAlive()值，输出true
                System.out.println(name + "：" + sd.isAlive());
            }
            // 只有当线程处于新建、死亡两种状态时isAlive()方法返回false。
            // 当i > 20，则该线程肯定已经启动过了，如果sd.isAlive()为假时，
            // 那只能是死亡状态了。
            if (i > 20 && !sd.isAlive()) {
                // 试图再次启动该线程
                System.out.println("试图再次启动该线程");
                sd.start();
            }
        }
    }
}

3.3 运行结果

上面程序中的执行结果如下：代码试图在线程已死亡的情况下再次调用start()方法来启动该线程。运行上面程序，将引发IllegaIThreadStateException异常，这表明处于死亡状态的线程无法再次运行了。

main-0
main-1
main-2
main-3
main-4
main-5
main-6
main-7
main-8
main-9
main-10
main-11
main-12
main-13
main-14
main-15
main-16
main-17
main-18
main-19
main-20
main：true
main-21
main-22
main-23
main-24
main-25
main-26
Thread-0-0
main-27
Thread-0-1
main-28
Thread-0-2
main-29
main-30
main-31
main-32
main-33
main-34
main-35
main-36
main-37
Thread-0-3
main-38
Thread-0-4
main-39
Thread-0-5
Thread-0-6
main-40
Thread-0-7
Thread-0-8
Thread-0-9
Thread-0-10
Thread-0-11
main-41
Thread-0-12
main-42
Thread-0-13
main-43
main-44
main-45
main-46
main-47
main-48
main-49
main-50
main-51
main-52
main-53
main-54
main-55
main-56
main-57
main-58
main-59
main-60
main-61
main-62
main-63
main-64
main-65
main-66
main-67
main-68
main-69
main-70
main-71
main-72
main-73
main-74
Thread-0-14
main-75
Thread-0-15
main-76
Thread-0-16
main-77
Thread-0-17
main-78
Thread-0-18
main-79
Thread-0-19
main-80
main-81
Thread-0-20
Thread-0-21
Thread-0-22
Thread-0-23
Thread-0-24
main-82
main-83
main-84
main-85
main-86
main-87
main-88
main-89
main-90
main-91
main-92
main-93
Thread-0-25
main-94
main-95
main-96
Thread-0-26
main-97
Thread-0-27
main-98
main-99
main-100
main-101
main-102
main-103
main-104
main-105
main-106
main-107
main-108
main-109
main-110
main-111
main-112
main-113
main-114
main-115
main-116
main-117
main-118
main-119
main-120
main-121
main-122
main-123
main-124
main-125
main-126
main-127
main-128
main-129
main-130
main-131
main-132
main-133
main-134
main-135
main-136
Thread-0-28
main-137
main-138
main-139
main-140
main-141
main-142
Thread-0-29
main-143
main-144
Thread-0-30
main-145
main-146
main-147
main-148
main-149
main-150
main-151
Thread-0-31
Thread-0-32
Thread-0-33
Thread-0-34
Thread-0-35
Thread-0-36
Thread-0-37
Thread-0-38
main-152
main-153
main-154
main-155
main-156
main-157
Thread-0-39
main-158
main-159
main-160
main-161
main-162
main-163
main-164
main-165
main-166
main-167
main-168
Thread-0-40
main-169
main-170
main-171
main-172
main-173
main-174
main-175
main-176
main-177
main-178
main-179
main-180
main-181
main-182
main-183
main-184
main-185
main-186
main-187
main-188
main-189
main-190
main-191
Thread-0-41
main-192
main-193
main-194
main-195
main-196
main-197
main-198
main-199
main-200
main-201
main-202
main-203
main-204
Thread-0-42
main-205
main-206
main-207
main-208
main-209
main-210
main-211
Thread-0-43
main-212
Thread-0-44
main-213
Thread-0-45
Thread-0-46
Thread-0-47
Thread-0-48
Thread-0-49
Thread-0-50
Thread-0-51
Thread-0-52
Thread-0-53
Thread-0-54
Thread-0-55
Thread-0-56
Thread-0-57
Thread-0-58
Thread-0-59
main-214
Thread-0-60
Thread-0-61
Thread-0-62
Thread-0-63
Thread-0-64
Thread-0-65
Thread-0-66
Thread-0-67
Thread-0-68
Thread-0-69
Thread-0-70
Thread-0-71
Thread-0-72
Thread-0-73
Thread-0-74
Thread-0-75
Thread-0-76
Thread-0-77
main-215
Thread-0-78
Thread-0-79
Thread-0-80
Thread-0-81
Thread-0-82
Thread-0-83
Thread-0-84
Thread-0-85
Thread-0-86
Thread-0-87
Thread-0-88
Thread-0-89
Thread-0-90
Thread-0-91
Thread-0-92
Thread-0-93
Thread-0-94
Thread-0-95
Thread-0-96
Thread-0-97
Thread-0-98
Thread-0-99
main-216
试图再次启动该线程
Exception in thread "main" java.lang.IllegalThreadStateException
	at java.lang.Thread.start(Thread.java:705)
	at StartDead.main(StartDead.java:36)

Process finished with exit code 1