Java并发编程使用锁和状态位来控制线程的执行顺序

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();
    }
}