线程同步模式

一、同步模式之顺序控制

1.固定运行顺序

1.1 wait notify

public class Test1 {
	// 用来同步的对象
	static Object obj = new Object();
	// t2 运行标记， 代表 t2 是否执行过
	static boolean isRun = false;
	public static void main(String[] args) {
		Thread t1 = new Thread(() -> {
			synchronized (obj) {
				// 如果 t2 没有执行过
				while (!isRun) { 
					try {
						// t1 先等一会
						obj.wait(); 
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
	 			}
			}
			System.out.println(1);
		});
		Thread t2 = new Thread(() -> {
			System.out.println(2);
			synchronized (obj) {
				// 修改运行标记
				t2runed = true;
				// 通知 obj 上等待的线程（可能有多个，因此需要用 notifyAll）
				obj.notifyAll();
			}
		});
		t1.start();
		t2.start();
	}
}

可以看到，实现上很麻烦：
首先，需要保证先 wait 再 notify，否则 wait 线程永远得不到唤醒。因此使用了『运行标记』来判断该不该 wait。
第二，如果有些干扰线程错误地 notify 了 wait 线程，条件不满足时还要重新等待，使用了 while 循环来解决此问题。
最后，唤醒对象上的 wait 线程需要使用 notifyAll，因为『同步对象』上的等待线程可能不止一个。
可以使用 LockSupport 类的 park 和 unpark 来简化上面的问题：

1.2 park unpark

先运行t2，再运行t1

public class Test2 {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            LockSupport.park();
            System.out.println("1");
        }, "t1");

        Thread t2 = new Thread(() -> {
            System.out.println("2");
            LockSupport.unpark(t1);
        }, "t2");

        t1.start();
        t2.start();
    }
}

park 和 unpark 方法比较灵活，他俩谁先调用，谁后调用无所谓。并且是以线程为单位进行『暂停』和『恢复』，不需要『同步对象』和『运行标记』。

2. 交替输出

交替输出 abc …

2.1 wait notify

public class Test1 {

    public static void main(String[] args) {
        WaitNotify waitNotify = new WaitNotify(1, 10);
        new Thread(() -> {
            waitNotify.print("a", 1, 2);
        }).start();
        new Thread(() -> {
            waitNotify.print("b", 2, 3);
        }).start();
        new Thread(() -> {
            waitNotify.print("c", 3, 1);
        }).start();
    }
}

/**
 * 输出内容     等待标记        下一个标记
 * a            1               2
 * b            2               3
 * c            3               1
 */
class WaitNotify {
    // 等待标记
    private int flag;
    // 循环次数
    private int loopNumber;

    public WaitNotify(int flag, int loopNumber) {
        this.flag = flag;
        this.loopNumber = loopNumber;
    }

    // 打印
    public void print(String str, int waitFlag, int nextFlag) {
        for (int i = 0; i < loopNumber; i++) {
            synchronized (this) {
                while (flag != waitFlag) {
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.print(str);
                flag = nextFlag;
                this.notifyAll();
            }
        }
    }
}

2.2 lock条件变量

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test2 {

    public static void main(String[] args) {
        AwaitSignal awaitSignal = new AwaitSignal(10);
        Condition a = awaitSignal.newCondition();
        Condition b = awaitSignal.newCondition();
        Condition c = awaitSignal.newCondition();
        new Thread(() -> {
            awaitSignal.print("a", a, b);
        }).start();
        new Thread(() -> {
            awaitSignal.print("b", b, c);
        }).start();
        new Thread(() -> {
            awaitSignal.print("c", c, a);
        }).start();

        try {
            Thread.sleep(1000);
            awaitSignal.lock();
            System.out.println("开始");
            a.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            awaitSignal.unlock();
        }
    }
}

class AwaitSignal extends ReentrantLock {
    private int loopNumber;

    public AwaitSignal(int loopNumber) {
        this.loopNumber = loopNumber;
    }

    /**
     * 打印
     * @param str 打印内容
     * @param current 进入哪个条件
     * @param next 下一个进入的条件
     */
    public void print(String str, Condition current, Condition next) {
        for (int i = 0; i < loopNumber; i++) {
            lock();
            try {
                current.await();
                System.out.print(str);
                next.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                unlock();
            }
        }
    }
}

2.3 park unpark

import java.util.concurrent.locks.LockSupport;

public class Test3 {

    private static Thread t2;
    private static Thread t3;

    public static void main(String[] args) {
        ParkUnpark parkUnpark = new ParkUnpark(10);
        Thread t1 = new Thread(() -> {
            parkUnpark.print("a", t2);
        });
        t2 = new Thread(() -> {
            parkUnpark.print("b", t3);
        });
        t3 = new Thread(() -> {
            parkUnpark.print("c", t1);
        });
        t1.start();
        t2.start();
        t3.start();
        LockSupport.unpark(t1);
    }
}

class ParkUnpark {
    private int loopNumber;

    public ParkUnpark(int loopNumber) {
        this.loopNumber = loopNumber;
    }

    public void print(String str, Thread next) {
        for (int i = 0; i < loopNumber; i++) {
            LockSupport.park();
            System.out.print(str);
            LockSupport.unpark(next);
        }
    }
}