Java线程生命周期的认识
对于线程的生命周期，在Java和操作系统中，在概念上有一点小小的不同。
在操作系统层面上，线程的生命周期如下：
1.新建
2.就绪
3.阻塞
4.运行
5.终止
而在Java层面上，则把线程的阻塞状态又划分出了2个状态，一个就是有限时间的等待，和无限时间的等待。
所以在Java层面来看，线程拥有如下几个状态：
1.新建
2.阻塞
3.无限时间等待
4.有限时间等待
5.就绪
6.运行
7.终止
1.无限等待队列：当调用Object.wait()、Thread.join()等方法时，线程进入无限时间的等待队列中。除非有其它线程执行notify或者notifyAll方法，不然这个线程是不会进入就绪状态。
2.有限等待队列：当调用 Thread.sleep()、Object.wait(long timeout)、Thread.join(long millis)等方法时，则线程就会进入有限时间的等待队列中。当达到指定的等待时间后，线程就会进入到就绪状态中。
知道了关于线程生命周期概念上的认识后，那么我们现在接着来了解下，如果想要控制线程的执行顺序，那么应该以哪些为切入点来实现。
控制线程顺序执行的方式
锁和状态位的认识
为了控制线程按序执行，这里有2个关键的认识需要了解下：
1.锁：通过锁，来保证线程的执行不受并发和并行的影响。这个是使线程执行顺序可控的基础。
2.状态位：通过状态位，起到一个线程通知的作用，从而控制线程的执行顺序。
下面具体说明下锁和状态位。
首先说明下为什么锁是线程执行顺序可控的基础。
首先需要知道，线程的调度是基于操作系统的调度算法的，是不可控的。那么以CPU单核的视角来看，多线程是并发执行的，以CPU多核的视角来看，多线程是并行执行的。
对于在并发和并行下多线程的执行状态，是不可控的乱序的。因为此时线程的执行顺序取决于操作系统的调度算法。所以在这里，我们需要通过锁，来保证当存在有多个线程被同时启动，且需要保证这些线程执行的顺序性的话，则就需要通过锁来保证这个待执行多线程集合中，一次只有一个线程被调度，从而来避免CPU并发和并行时线程执行乱序的现象。
现在接着再说明下状态位的作用。
这里的状态位就相当于是线程通信的这样的一个作用。线程可以通过对这个状态位的判断，来判断是否可以执行。那么这也就意味着，我们可以根据自己的需要，去调整状态位的变化，从而达到控制线程执行状态的效果，也就是让线程在某种顺序下被调度执行。
切换线程状态的方式
知道了关于锁和状态位的相关认识后，接着来了解下切换线程状态的方式。
1.wait()：让当前线程进入无限时间等待队列。
2.notifyAll()：通知所有处在等待队列的线程进入就绪状态，即可运行状态。
知道了以上这些概念上的认识后，那么我们来尝试实现几种控制线程操作的场景。
实际应用
1.控制两个线程交替执行
要让两个线程交替执行，那么需要有一个通知机制，让这两个线程互相知道它们执行的状态，即执行完成与否。
比如当线程1执行完后，线程2才可以被执行。那么通过这个通知机制，比如从false到true状态的切换，线程2可以通过判断这个变量是否等于true，来判断自己是否可以执行。
这里以变量A来举例说明，变量A表明线程1的执行状态，为true则表明线程1已执行完毕，那么也意味线程2可以执行。所以，当线程1执行完毕后，就需要更新变量A为true，并唤醒正在等待的线程2，并释放锁，使得线程2有机会获得锁，并进入运行状态。
那么被唤醒了的线程2，由于线程1释放了锁，所以线程2可以获取到锁并进入运行状态，并且通过判断变量A的状态，来确定是否继续执行，当确认线程2可以执行，并在执行完成后，线程2更新变量A的状态，为false，表明线程1可以执行，线程2不可以执行，且同时，唤醒线程1，使自己进入等待队列，并释放锁，从而使线程1有机会进入运行状态。
通过这个过程，我们可以看到，在基于变量A做线程通知，及锁的控制下，保证一次只可以有一个线程被调度执行的情况下，我们可以根据自己的需要，去控制线程的执行状态。
实现这个需求的大体思路如下：
1.使用锁，来保证线程1和线程2一次只可以执行一个，以避免并发和并行，导致的乱序问题。
2.使用状态位，true或false，来控制线程1和线程2执行的时机。
下面附上实现代码：
public class SynchronizedExample {
private static final Object lock = new Object();
private static boolean isThreadAExecuted = false;
public static void main(String[] args) {
Thread threadA = new Thread(() -> {
synchronized (lock) {
while (!isThreadAExecuted) {
try {
// 使线程A进入等待队列
lock.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
System.out.println("Thread A is executing");
// 通过这个状态位，通知线程B可以执行，自己不可以执行
isThreadAExecuted = true;
// 唤醒线程B
lock.notifyAll();
}
});
Thread threadB = new Thread(() -> {
synchronized (lock) {
while (isThreadAExecuted) {
try {
// 由于线程A还未执行，所以自己还不可以执行
lock.wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
System.out.println("Thread B is executing");
// 通过这个状态位，通知线程A可以执行，自己不可以执行
isThreadAExecuted = false;
// 唤醒线程A
lock.notifyAll();
}
});
threadA.start();
threadB.start();
}
}
2.控制线程2在线程1和3之后执行，且线程1和3顺序不需要控制
那么如果是3个以上的线程呢？比如1、2、3，这3个线程，线程2的执行顺序必须要在1和3之后，而1和3的执行顺序则是可以乱序的。那么在这种情况下，我们实现的思路可以是怎样的呢？
首先我们依然需要使用共享变量，以及锁。
首先需要2个状态位，即变量，分别对应线程1和线程3的执行状态，执行完成与否。线程2可以通过这2个状态位，来决定执行的时机。且当线程2执行完成了之后，可以通过重置这2个状态位，来让线程1和线程3，进入到可运行的状态。
所以实现这个需求的大体思路如下：
1.使用锁，避免并发和并行的影响，以保证线程可以可控的按序执行。
2.使用两个状态位分别对应线程1和3的执行状态。
3.线程1和3通过各自的状态位，来判断是否进入等待还是可执行状态。
4.线程2通过线程1和3的状态位，来判断是否进入等待还是可执行状态。
5.线程2执行完成后，重置线程1和3对应的状态位，从而使自身进入到等待状态，且使线程1和3进入到可运行状态。
下面附上代码：
public class ThreadOrderExample {
private static final Object lock = new Object();
private static boolean t1Done = false;
private static boolean t3Done = false;
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
synchronized (lock) {
try {
if (!t1Done) {
System.out.println("Thread 1 is running");
// 标记线程1已执行完，从而避免被唤醒而导致的重复执行
t1Done = true;
lock.notifyAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t3 = new Thread(() -> {
synchronized (lock) {
try {
if (!t3Done) {
System.out.println("Thread 3 is running");
// 标记线程3已执行完，从而避免被唤醒而导致的重复执行
t3Done = true;
lock.notifyAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t2 = new Thread(() -> {
synchronized (lock) {
try {
while (!t1Done || !t3Done) {
lock.wait();
}
System.out.println("Thread 2 is running");
// 重置线程1和3的执行状态，使其可以进入可运行的状态，从而使线程2进入等待状态，线程1和3进入可运行状态
t1Done = false;
t3Done = false;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
t3.start();
t2.start();
}
}
![[米联客-安路飞龙DR1-FPSOC] UDP通信篇连载-01 以太网协议介绍](https://i-blog.csdnimg.cn/direct/5d1c77471d6048fba50dd150057a2b9c.png)
