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.控制两个线程交替执行

要让两个线程交替执行，那么首先需要有一个通知机制，让这两个线程互相可以知道它们的执行状态，即执行完成与否，并可以基于这个状态去判断自己是否可以执行。

然后还需要保证这2个线程，一次只可以执行一个，且在执行期间线程操作的原子性，从而避免并发和并行时带来的线程执行乱序的现象。

这里以变量A来举例，通过这个变量A起到一个线程通知的作用。

变量A表明线程1的执行状态，为true则表明线程1已执行完毕，那么也意味线程2可以执行。所以，当线程1执行完毕后，就需要更新变量A为true，让线程2知道自己可以进入运行状态。

线程2获取锁，并通过判断变量A的状态，来确定是否进入运行状态。当线程2执行完成后，线程2更新变量A的状态，为false，表明线程1可以执行，线程2不可以执行，然后让自己进入到等待队列中，并释放锁，使线程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();
    }
}