并发编程（第四章 共享模型之管程）

本章内容

• 共享问题
• synchronized
• 线程安全分析
• Monitor
• wait/notify
• 线程状态转换
• 活跃性
• Lock

一、共享带来的问题

1、小故事

• 老王（操作系统）有一个功能强大的算盘（CPU），现在想把它租出去，赚一点外快
  
• 小南、小女（线程）来使用这个算盘来进行一些计算，并按照时间给老王支付费用
• 但小南不能一天24小时使用算盘，他经常要小憩一会（sleep），又或是去吃饭上厕所（阻塞io操作），有时还需要一根烟，没烟时思路全无（wait）这些情况统称为（阻塞）
  
• 在这些时候，算盘没利用起来（不能收钱了），老王觉得有点不划算
• 另外，小女也想用用算盘，如果总是小南占着算盘，让小女觉得不公平
• 于是，老王灵机一动，想了个办法【让他们每人用一会，轮流使用算盘】
• 这样，当小南阻塞的时候，算盘可以分给小女使用，不会浪费，反之亦然
• 最近执行的计算比较复杂，需要存储一些中间结果，而学生们的脑容量（工作内存）不够，所以老王申请了一个笔记本（主寸），把一些中间结果先记在本上
• 计算流程是这样的
  
• 但是由于分时系统，有一天还是发生了事故
• 小南刚读取了初始值0做了个+1运算，还没来得及写回结果
• 老王说【小南，你的时间到了，该别人了，记住结果走吧！】，于是小南念叨着【结果是1，结果是1…】不甘心地到一边待着去了（上下文切换）
• 老王说【小女，该你了】，小女看到了笔记本上还写着0做了一个-1运算，将结果-1写入笔记本
• 这时小女的时间也用完了，老王又叫醒了小南：【小南，把你上次的题目算完吧】，小南将他脑海中的结果1写入了笔记本
  
• 小南和小女都觉得自己没做错，但笔记本里的结果是1而不是0

2、java体现

两个线程对初始值为0的静态变量一个做自增，一个做自减，各做5000次，结果是0吗？

static int count = 0;
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                count--;
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("最终结果为：{}", count);
    }

某次执行输出结果：

3、问题分析

以上的结果可能是正数、负数、零。为什么呢？因为java中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析。

1、例如对于i++而言（i为静态变量），实际会产生如下的JVM字节码指令：

2、而对应i–也是类似：

3、而java的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：

4、如果是单线程以上8行代码是顺序执行（不会交错）没有问题：

5、但多线程下这8行代码可能交错运行：
5.1 出现负数的情况：

5.2 出现正数的情况：

4、临界区Critical Section

• 一个程序运行多个线程本身是没有问题的
• 问题出在多个线程访问共享资源
  –多个线程读共享资源其实也没有问题
  –在多个线程对共享资源读写操作时发生指令交错，就会出现问题
• 一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

例如：下面代码中的临界区

5、竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件。

二、synchronized解决方案

*1、应用之互斥

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

• 阻塞式的解决方案：synchronzied，lock
• 非阻塞式的解决方案：原子变量

本次课使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称为【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

注意
虽然java中互斥和同步都可以采用synchronized关键字来完成，但它们还是有区别的：
1、互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码；
2、同步是由于线程执行的先后，顺序不同、需要一个线程等待其它线程运行到某个点

2、synchronized
语法

synchronized(对象) // 线程1， 线程2(blocked) {
    临界区
}

解决上述代码多线程问题

static int count = 0;
    static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock) {
                    count++;
                }
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock) {
                    count--;
                }
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("最终结果为：{}", count);
 }

3、synchornized理解

1、你可以做这样类比：

• synchronized（对象）中的对象，可以想象为一个房间（room），有唯一入门（门）房间只能一次进入一人进行计算，线程t1，t2想象成两个人；
• 当线程t1执行到synchronize（room）时就好比t1进入这个房间，并锁住了门拿走了钥匙，在门内执行count++代码；
• 这时候如果t2也运行到了synchronize（room）时，它发现门被锁住了，只能在门外等待，发生了上下文切换，阻塞住了；
• 这中间即使t1的cpu时间片不幸用完，被踢出了门外（不要错误理解为锁住了对象就能一直执行下去哦），这时门还是锁住的，t1仍拿着钥匙，t2线程还在阻塞状态进不来，只有下次轮到t1自己再次获得时间片时才能开门进入；
• 当t1执行完synchronized{}块内的代码，这时候才会从obj房间出来并解开门上的锁，唤醒t2线程把钥匙给他。t2线程这时才可以进入obj房间，锁住了门拿上钥匙，执行它的count–代码；

2、用图来表示

4、思考

1、synchronized实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。
2、为了加深理解，请思考下面的问题

• 如果把 synchronized(obj) 放在 for 循环的外面，如何理解?-- 原子性
• 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作?-- 锁对象
• 如果 t1 synchronized(obj) 而 t2 没有加会怎么样?如何理解?-- 锁对象（如果t2没有加锁，不会被阻塞；在t1没有释放锁且进行时间片用完的情况下，t2会执行代码，也才造成多线程共享资源问题）

5、面向对象改进

把需要保护的共享变量放入一个类

public class TestDemo2 {

    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.increment();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.decrease();
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("最终结果为：{}", room.getCount());
    }
}

class Room {
    private int count = 0;

    public void increment() {
        synchronized (this) {
            count ++;
        }
    }

    public void decrease() {
        synchronized (this) {
            count --;
        }
    }

    public int getCount() {
        synchronized (this) {
            return count;
        }
    }
}

三、方法上的synchronized

1、分为以下两种方式

class Test{
  	public synchronized void test() {
    
    } 
}
等价于
class Test{
	public void test() {
		synchronized(this) {
		
		}
	} 
}

class Test{
  	public synchronized static void test() {
    
    } 
}
等价于
class Test{
	public static void test() {
		synchronized(Test.class) {
		
		}
	} 
}

2、不加synchronized的方法
不加synchronzied的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进入的）

3、所谓的“线程八锁”

情况1: 12或21

@Slf4j(topic = "c.Number") 
class Number{
	public synchronized void a() { 
	  log.debug("1");
    }
	public synchronized void b() {
	  log.debug("2"); 
	}
}
    
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start(); 
    new Thread(()->{ n1.b(); }).start();
}

情况2: 1s后12，或2 1s后1

@Slf4j(topic = "c.Number") 
class Number{
	public synchronized void a() { 
		sleep(1);
		log.debug("1"); 
	}
	public synchronized void b() { 
	  log.debug("2");
	} 
}
public static void main(String[] args) { 
	Number n1 = new Number();
	new Thread(()->{ n1.a(); }).start(); 
	new Thread(()->{ n1.b(); }).start();
}

情况3: 3 1s12 或 23 1s后 1 或 32 1s后 1

@Slf4j(topic = "c.Number")
class Number{
	public synchronized void a() {
		sleep(1);
		log.debug("1"); }
	public synchronized void b() { 
	    log.debug("2");
	}
	public void c() {
		log.debug("3"); 
	}
}
public static void main(String[] args) { 
	Number n1 = new Number();
	new Thread(()->{ n1.a(); }).start(); 
	new Thread(()->{ n1.b(); }).start(); 
	new Thread(()->{ n1.c(); }).start();
}

情况4: 2 1s后1

@Slf4j(topic = "c.Number") 
class Number{
	public synchronized void a() { 
		sleep(1);
		log.debug("1"); }
	public synchronized void b() { 
		log.debug("2");
	} 
}
public static void main(String[] args) { 
	Number n1 = new Number();
	Number n2 = new Number();
	new Thread(()->{ n1.a(); }).start(); 
	new Thread(()->{ n2.b(); }).start();
}

情况5: 2 1s后1

@Slf4j(topic = "c.Number") 
class Number{
	public static synchronized void a() { sleep(1);
		log.debug("1"); }
	public synchronized void b() { 
		log.debug("2");
	}
}
public static void main(String[] args) { 
	Number n1 = new Number();
	new Thread(()->{ n1.a(); }).start(); 
	new Thread(()->{ n1.b(); }).start();
}

情况6: 1s后12，或2 1s后1

@Slf4j(topic = "c.Number") 
class Number{
	public static synchronized void a() { sleep(1);
		log.debug("1"); }
	public static synchronized void b() { 
		log.debug("2");
	} 
}
public static void main(String[] args) { 
	Number n1 = new Number();
	new Thread(()->{ n1.a(); }).start(); 
	new Thread(()->{ n1.b(); }).start();
}

情况7: 2 1s后1

@Slf4j(topic = "c.Number") 
class Number{
	public static synchronized void a() { sleep(1);
		log.debug("1"); }
	public synchronized void b() { 
		log.debug("2");
	} 
}
public static void main(String[] args) { 
	Number n1 = new Number();
	Number n2 = new Number();
	new Thread(()->{ n1.a(); }).start(); 
	new Thread(()->{ n2.b(); }).start();
}

情况8: 1s后12，或2 1s后1

@Slf4j(topic = "c.Number") 
class Number{
	public static synchronized void a() {
		sleep(1);
		log.debug("1"); }
	public static synchronized void b() { 
		log.debug("2");
	} 
}
public static void main(String[] args) { 
	Number n1 = new Number();
	Number n2 = new Number();
	new Thread(()->{ n1.a(); }).start(); 
	new Thread(()->{ n2.b(); }).start();
}

四、变量的线程安全分析

1、成员变量和静态变量是否线程安全？

• 如果它们没有共享，则线程安全
• 如果它们被共享了，根据它们的状态是否能够改变，又分两种情况
  – 如果只有读操作，则线程安全
  – 如果有读写操作，则这段代码是临界区，需要考虑线程安全

2、局部变量是否线程安全？

• 局部变量是线程安全的
• 但局部变量引用的对象则未必
  – 如果该对象没有逃离方法的作用访问，它是线程安全的
  – 如果该对象逃离方法的作用范围，需要考虑线程安全

3、局部变量线程安全分析

 public static void test1() { 
    int i = 10;
    i++; 
}

每个线程调用test1()方法时局部变量i，会在每个线程的栈帧内存中被创建多份，因此不存在共享

如图

ps：局部变量的引用稍有不同

1、先看一个成员变量的例子

class ThreadUnsafe {
	    ArrayList<String> list = new ArrayList<>(); 
		public void method1(int loopNumber) {
			for (int i = 0; i < loopNumber; i++) { // { 临界区, 会产生竞态条件   
				method2();
				method3();
			    // } 临界区 
			}
		}
		private void method2() { 
		  list.add("1");
		}
		private void method3() { 
		  list.remove(0);
		} 
}

执行

static final int THREAD_NUMBER = 2; 
static final int LOOP_NUMBER = 200; 
public static void main(String[] args) {
	ThreadUnsafe test = new ThreadUnsafe(); 
	for (int i = 0; i < THREAD_NUMBER; i++) {
	   new Thread(() -> { 
	      test.method1(LOOP_NUMBER);
	  }, "Thread" + i).start(); }
}

其中一种情况是，如果线程2还未add，线程1 remove就会报错：

分析：

• 无论哪个线程中的method2引用的都是同一个对象中的list成员变量
• method3与method2分析相同

2、将list修改为局部变量

class ThreadSafe {
	public final void method1(int loopNumber) {
		ArrayList<String> list = new ArrayList<>(); 
		for (int i = 0; i < loopNumber; i++) {
			method2(list);
			method3(list); 
		}
	}
	private void method2(ArrayList<String> list) { 
		list.add("1");
	}
	private void method3(ArrayList<String> list) { 
		list.remove(0);
	} 
}

那么就不会有上述问题了

分析：

• list是局部变量，每个线程调用时会创建其不同实例，没有共享
• 而method2的参数是从method1中传递过来的，与method1中引用同一个对象
• method3的参数分析与method2相同
  

方法访问修饰符带来的思考，如果把method2和method3的方法修改为public会不会代理线程安全问题？

• 情况1:有其它线程调用method2和method3
• 情况2:在情况1的基础上，为ThreadSafe类添加子类，子类覆盖method2或method3方法，即

class ThreadSafe {
	public final void method1(int loopNumber) {
		ArrayList<String> list = new ArrayList<>(); 
			for (int i = 0; i < loopNumber; i++) {
				method2(list);
				method3(list); 
			}
	}
	
	private void method2(ArrayList<String> list) {
		list.add("1");
	}
	
	private void method3(ArrayList<String> list) { 
		list.remove(0);
	} 
}

class ThreadSafeSubClass extends ThreadSafe{ 
	@Override
	public void method3(ArrayList<String> list) { 
		new Thread(() -> {
			list.remove(0); }).start();
	} 
}

从这个例子可以看出private或final提供【安全】的意义所在，请体会开闭原则中的【闭】

4、常见线程安全类

• String
• Integer
• StringBuffer
• Random
• Vector
• Hashtable
• java.util.concurrent包下的类

这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。也可以理解为：

Hashtable table = new Hashtable();

new Thread(() -> {
   table.put("key","value1");
}).start();

new Thread(() -> {
   table.put("key","value2");
}).start();

1、它们的每个方法是原子的；
2、但注意它们多个方法的组合不是原子的，见后面分析。

1、线程安全类方法的组合
分析下面代码是否线程安全？

Hashtable table = new Hashtable();
// 线程1，线程2
if( table.get("key") == null ) {
   table.put("key",value);
}

2、不可变类线程安全性

1、String、Integer等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的；
2、有同学或许有疑问，String有replace，substring等方法【可以】改变值啊，那么这些方法又是如何保证线程安全的呢？

public class Immutable {
	private int value = 0;

    public Immutable(int value) {
		this.value = value;
    }

    public int getValue() {
        return this.value;
	}
}

如果想增加一个增加的方法呢？

public class Immutable {
    private int value = 0;

    public Immutable(int value) {
        this.value = value;
    }
 
    public int getValue() {
 		return this.value;
	}

	public Immutable add(int v) {
	    return new Immutable(this.value + v);
	}
}

3、案例分析

五、习题

1、卖票联系

@Slf4j(topic = "c.ExerciseSell")
public class ExerciseSell {
    public static void main(String[] args) throws InterruptedException {
        // 模拟多人买票
        TicketWindow window = new TicketWindow(1000);

        // 所有线程的集合
        List<Thread> threadList = new ArrayList<>();
        // 卖出的票数统计
        List<Integer> amountList = new Vector<>();
        for (int i = 0; i < 2000; i++) {
            Thread thread = new Thread(() -> {
                // 买票
                int amount = window.sell(random(5));
                // 统计买票数
                amountList.add(amount);
            });
            threadList.add(thread);
            thread.start();
        }

        for (Thread thread : threadList) {
            thread.join();
        }

        // 统计卖出的票数和剩余票数
        log.debug("余票：{}",window.getCount());
        log.debug("卖出的票数：{}", amountList.stream().mapToInt(i-> i).sum());
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~5
    public static int random(int amount) {
        return random.nextInt(amount) + 1;
    }
}

// 售票窗口
class TicketWindow {
    private int count;

    public TicketWindow(int count) {
        this.count = count;
    }

    // 获取余票数量
    public int getCount() {
        return count;
    }

    // 售票
    public synchronized int sell(int amount) {
        if (this.count >= amount) {
            this.count -= amount;
            return amount;
        } else {
            return 0;
        }
    }
}

2、转账练习

@Slf4j(topic = "c.ExerciseTransfer")
public class ExerciseTransfer {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                a.transfer(b, randomAmount());
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                b.transfer(a, randomAmount());
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        // 查看转账2000次后的总金额
        log.debug("total:{}", (a.getMoney() + b.getMoney()));
    }

    // Random 为线程安全
    static Random random = new Random();

    // 随机 1~100
    public static int randomAmount() {
        return random.nextInt(100) + 1;
    }
}

// 账户
class Account {
    private int money;

    public Account(int money) {
        this.money = money;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    // 转账
    public void transfer(Account target, int amount) {
        synchronized(Account.class) {
            if (this.money >= amount) {
                this.setMoney(this.getMoney() - amount);
                target.setMoney(target.getMoney() + amount);
            }
        }
    }
}

六、Monitor概念

1、java对象头

以32位虚拟机为例

普通对象

数组对象

其中Mark Word结构为

64位虚拟机Mark Word

参考资料

2、原理之Monitor（锁）

1、Monitor被翻译为监视器或管程；
2、每个java对象都可以关联一个Monitor对象，如果使用synchronized给对象上锁（重量级）之后，该对象头的Mark Word中就被设置指向Monitor对象的指针；
3、Monitor结构如下：

• 刚开始Monitor中Owner为null
• 当Thread-2执行synchronized（obj）就会将Monitor的所有者Owner置为Thread-2，Monitor中只能有一个Owner
• 在Thread-2上锁的过程中，如果Thread-3，Thread-4，Thread-5也来执行synchronized（obj），就会进入EntryList BLOCKED
• Thread-2执行完同步代码块的内容，然后唤醒EntryList中等待的线程来竞争锁，竞争时是非公平的
• 图中WaitSet中的Thread-0，Thread-1是之前获得过锁，但条件不满足进入WAITING状态的线程，后面讲wait-notify时会分析

注意：

• synchronized必须是进入同一个对象的monitor才有上述的效果
• 不加synchronized的对象不会关联监视器，不遵从以上规则

3、原理之synchronized

static final Object lock = new Object(); 
static int counter = 0;

public static void main(String[] args) { 
	synchronized (lock) {
		counter++; 
	}
}

对应的字节码为：

注意：
方法级别的synchronized不会在字节码指令中有所体现

4、小故事

故事角色

• 老王 - JVM
• 小南 - 线程
• 小女 - 线程
• 房间 - 对象
• 房间门上 - 防盗锁 - Monitor
• 房间门上 - 小南书包 - 轻量级锁
• 房间门上 - 刻上小南大名 - 偏向锁
• 批量重刻名 - 一个类的偏向锁撤销到达20阈值
• 不能刻名字 - 批量撤销该类对象的偏向锁，设置该类不可偏向

1、小南要使用房间保证计算不被其它人干扰（原子性），最初，他用的是防盗锁，当上下文切换时，锁住门。这样，即使他离开了，别人也进不了门，他的工作就是安全的。
2、但是，很多情况下没人跟他来竞争房间的使用权。小女是要用房间，但使用的时间上是错开的，小南白天用，小女晚上用。每次上锁太麻烦了，有没有更简单的办法呢？
3、小南和小女商量了一下，约定不锁门了，而是谁用房间，谁把自己的书包挂在门口，但他们的书包样式都一样，因此每次进门前得翻翻书包，看课本是谁的，如果是自己的，那么就可以进门，这样省的上锁解锁了。万一书包不是自己的，那么就在门外等，并通知对方下次用锁门的方式。
4、后来，小女回老家了，很长一段时间都不会用这个房间。小南每次还是挂书包，翻书包，虽然比锁门省事了，但仍然觉得麻烦。
5、于是，小南干脆在门上刻上了自己的名字：【小南专属房间，其它人勿用】，下次来用房间时，只要名字还在，那么说明没人打扰，还是可以安全地使用房间。如果这期间有其它人要用这个房间，那么由使用者将小南刻的名字擦掉，升级为挂书包的方式。
6、同学们都放假回老家了，小南就膨胀了，在20个房间刻上了自己的名字，想进哪个进哪个。后来他自己放假回老家了，这时小女回来了（她也要用这些房间），结果就是得一个个地擦掉小南刻的名字，升级为挂书包的方式。老王觉得这成本有点高，提出了一种批量重刻名的方法，他让小女不用挂书包了，可以直接在门上刻上自己的名字。
7、后来，刻名的现象越来越频繁，老王受不了了：算了，这些房间都不能刻名了，只能挂书包。

5、原理之synchronized进阶

1、轻量级锁

1、轻量级锁的使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化；
2、轻量级锁对使用者是透明的，即语法仍然是synchronized；
3、假设有两个方法同步块，利用同一个对象加锁。

static final Object obj = new Object(); 
public static void method1() {
	synchronized( obj ) { 
		// 同步块 A
		method2(); 
	}
}
public static void method2() {
	synchronized( obj ) { 
	// 同步块 B
	} 
}

• 创建锁记录（Lock Record）对象，每个线程的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word
  
• 让锁记录中Object reference指向锁对象，并尝试用cas替换Object的Mark Word，将Mark Word的值存入锁记录
  
• 如果cas替换成功，对象头中存储了锁记录地址和状态00，表示由该线程给对象加锁，这时图示如下
  
• 如果cas失败，有两种情况
  – 如果是其它线程已经持有了该Object的轻量级锁，这时表明有竞争，进入锁膨胀过程；
  – 如果是自己执行了synchronized锁重入，那么再添加一条Lock Record作为重入的计数
  
• 当退出synchronized代码块（解锁时）如果有取值为null的锁记录，表示有重入，这时重置锁记录，表示重入计数减一
  
• 当退出synchronized代码块（解锁时）锁记录的值不为null，这时使用cas将Mark Word的值恢复给对象头
  – 成功，则解锁成功
  – 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

2、锁膨胀

如果在尝试加轻量级锁的过程中，CAS操作无法成功，这时一种情况就是其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

static Object obj = new Object(); 
public static void method1() {
	synchronized( obj ) { 
		// 同步块
	} 
}

• 当Thread-1进行轻量级加锁时，Thread-0已经对该对象加了轻量级锁
  
• 这时Thread-1加轻量级锁失败，进入锁膨胀流程
  – 即为Object对象申请Monitor锁，让Object指向重量级锁地址
  – 然后自己进入Monitor的EntryList BLOCKED
  
• 当Thread-0退出同步块解锁时，使用cas将Mark Word的值恢复给对象头，失败。这时回进入重量级解锁流程，即按照Monitor地址找到Monitor对象，设置Owner为null，唤醒EntryList中BLOCKED线程。

3、自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。

自旋重试成功的情况

自旋重试失败的情况

• 自旋会占用CPU时间，单核CPU自旋就是浪费，多核CPU自旋才能发挥优势；
• 在Java6之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能；
• Java7之后不能控制是否开启自旋功能。

4、偏向锁

1、轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行CAS操作。
2、Java6中引入了偏向锁来做进一步优化：只有第一次使用CAS将线程ID设置到对象的Mark Word头，之后发现这个线程ID是自己的就表示没有竞争，不用重新CAS。以后只要不发生竞争，这个对象就归该线程持有
3、例如：

static final Object obj = new Object(); 
public static void m1() {
	synchronized( obj ) { 
		// 同步块 A
		m2(); 
	}
}
public static void m2() {
	synchronized( obj ) { 
		// 同步块 B
		m3(); 
	}
}
public static void m3() {
	synchronized( obj ) {
		// 同步块 C 
	}
}

4.1偏向状态

回忆一下对象头格式

一个对象创建时：

• 如果开启了偏向锁（默认开启），那么对象创建后，markword值为0x05即最后3位为101，这时它的thread、epoch、age都为0；
• 偏向锁默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加VM参数- XX:BiasedLockingStartupDelay=0来禁用延迟
• 如果没有开启偏向锁，那么对象创建后，markword值为0x01即最后3位为001，这时它的hashcode、age都为0，第一次用到hashcode时才会赋值

1）测试延迟特性
2）测试偏向锁

class Dog {}

利用jol第三方工具来查看对象头信息（注意这里我扩展了jol让它输出更为简洁）

// 添加虚拟机参数 -XX:BiasedLockingStartupDelay=0
public static void main(String[] args) throws IOException {
	Dog d = new Dog();
	ClassLayout classLayout = ClassLayout.parseInstance(d);
	
	new Thread(() -> {
		log.debug("synchronized 前"); 
		System.out.println(classLayout.toPrintableSimple(true));
			synchronized (d) {
				log.debug("synchronized 中");
				System.out.println(classLayout.toPrintableSimple(true)); 
			}
		log.debug("synchronized 后");
		System.out.println(classLayout.toPrintableSimple(true)); }, "t1").start();
}

输出

注意：
处于偏向锁的对象解锁后，线程id仍存储于对象头中

3）测试禁用
在上面测试代码运行时在添加VM参数-XX:-UseBiasedLocking禁用偏向锁

输出

4）测试hashCode

正常状态对象一开始是没有hashCode的，第一次调用才生成。

4.2撤销-调用对象hashCode

调用了对象的hashCode，但偏向锁的对象MarkWord中存储的是线程id，如果调用hashCode会导致偏向锁被撤销

• 轻量级锁会在锁记录中记录hashCode
• 重量级锁会在Monitor中记录hashCode
  在调用hashCode后使用偏向锁，记得去掉-XX:-UseBiasedLocking

输出

4.3撤销-其它线程使用对象

当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁

private static void test2() throws InterruptedException {

	Dog d = new Dog();
	Thread t1 = new Thread(() -> {
		synchronized (d) { 
			log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
		synchronized (TestBiased.class) {
			TestBiased.class.notify(); 
		}
		// 如果不用 wait/notify 使用 join 必须打开下面的注释
		// 因为:t1 线程不能结束，否则底层线程可能被 jvm 重用作为 t2 线程，底层线程 id 是一样的 
				/*try {
					System.in.read();
				} catch (IOException e) {
					e.printStackTrace(); 
				}*/
	}, "t1"); t1.start();
	
	Thread t2 = new Thread(() -> { 
		synchronized (TestBiased.class) {
			try { 
				TestBiased.class.wait();
			} catch (InterruptedException e) { 
				e.printStackTrace();
			} 
		}
		log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true)); 
		synchronized (d) {
			log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
		log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true)); 
	}, "t2");
	t2.start(); 
}

输出

4.4撤销-调用wait/notify

public static void main(String[] args) throws InterruptedException { 
	Dog d = new Dog();
	
	Thread t1 = new Thread(() -> { 
		log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true)); 
		synchronized (d) {
			log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true)); 
			try {
				d.wait();
			} catch (InterruptedException e) {
				e.printStackTrace(); 
			}
			log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true)); }
		}, "t1"); 
		t1.start();
	
	new Thread(() -> { 
		try {
			Thread.sleep(6000);
		} catch (InterruptedException e) {
			e.printStackTrace(); 
		}
		synchronized (d) { 
			log.debug("notify"); 
			d.notify();
		}
	}, "t2").start();
}

输出

4.5批量重偏向

1、如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程T1的对象仍有机会重新偏向T2，重偏向会重置对象的Thread ID；
2、当撤销偏向锁阈值超过20次后，jvm会这样觉得，我是不是偏向错了呢？于是会在给这些对象加锁时重新偏向至加锁线程。

private static void test3() throws InterruptedException {

        Vector<Dog> list = new Vector<>();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 30; i++) {
                Dog d = new Dog();
                list.add(d);
                synchronized (d) {
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                }
            }
            synchronized (list) {
                list.notify();
            }
        }, "t1");
        t1.start();


        Thread t2 = new Thread(() -> {
            synchronized (list) {
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.debug("===============> ");
            for (int i = 0; i < 30; i++) {
                Dog d = list.get(i);
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                synchronized (d) {
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                }
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
        }, "t2");
        t2.start();
    }

输出

4.6批量撤销

当撤销偏向锁阈值超过40次后，jvm会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的。

static Thread t1, t2, t3;

    private static void test4() throws InterruptedException {
        Vector<Dog> list = new Vector<>();

        int loopNumber = 39;
        t1 = new Thread(() -> {
            for (int i = 0; i < loopNumber; i++) {
                Dog d = new Dog();
                list.add(d);
                synchronized (d) {
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                }
            }
            LockSupport.unpark(t2);
        }, "t1");
        t1.start();

        t2 = new Thread(() -> {
            LockSupport.park();
            log.debug("===============> ");
            for (int i = 0; i < loopNumber; i++) {
                Dog d = list.get(i);
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                synchronized (d) {
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                }
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
            LockSupport.unpark(t3);
        }, "t2");
        t2.start();

        t3 = new Thread(() -> {
            LockSupport.park();
            log.debug("===============> ");
            for (int i = 0; i < loopNumber; i++) {
                Dog d = list.get(i);
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                synchronized (d) {
                    log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
                }
                log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
            }
        }, "t3");
        t3.start();

        t3.join();
        log.debug(ClassLayout.parseInstance(new Dog()).toPrintableSimple(true));
    }

参考资料
资料1
资料2
资料3

5、锁消除

@Fork(1) 
@BenchmarkMode(Mode.AverageTime) 
@Warmup(iterations=3)
@Measurement(iterations=5) 
@OutputTimeUnit(TimeUnit.NANOSECONDS) 
public class MyBenchmark {
	static int x = 0;
	
	@Benchmark
	public void a() throws Exception {
		x++; 
	}
	
	@Benchmark
	public void b() throws Exception { 
		Object o = new Object(); synchronized (o) {
			x++;
		}
	}
}

java -jar benchmarks.jar

java -XX:-EliminateLocks -jar benchmarks.jar

锁粗化
对相同对象多次加锁，导致线程发生多次重入，可以使用锁粗化方式来优化，这不同于之前讲的细分锁的粒度。

七、wait notify

1、为什么需要wait

• 由于条件不满足，小南不能继续进行计算
• 但小南如果一直占用着锁，其它人就得一直阻塞，效率太低
  
• 于是老王单开了一间休息室（调用wait方法），让小南到休息室（WaitSet）等着去了，但这时锁释放开，其它人可以由老王随机安排进屋
• 直到小M将烟送来，大叫一声【你的烟到了】（调用notify方法）
  
• 小南于是可以离开休息室，重新进入竞争锁的队列
  

2、原理之wait / notify

• Owner线程发现条件不满足，调用wait方法，即可进入WaitSet变为WAITING状态
• BLOCKED和WAITING的线程都处于阻塞状态，不占用CPU时间片
• BLOCKED线程会在Owner线程释放锁时唤醒
• WAITING线程会在Owner线程调用notify或notifyAll时唤醒，但唤醒后并不意味着立刻获得锁，仍需进入EntryList重新竞争

3、API介绍

• obj.wait()让进入object监视器的线程到waitSet等待
• obj.notify()在object上正在waitSet等待的线程中挑一个唤醒
• obj.notifyAll()让object上正在waitSet等待的线程全部唤醒

他们都是线程之间进行协作的手段，都属于Object对象的方法。必须获得此对象的锁，才能调用这几个方法

final static Object obj = new Object(); 

public static void main(String[] args) {

	new Thread(() -> { 
		synchronized (obj) {
			log.debug("执行...."); 
			try {
				obj.wait(); // 让线程在obj上一直等待下去 
			} catch (InterruptedException e) {
				e.printStackTrace(); 
			}
			log.debug("其它代码...."); 
		}
	}).start();
	
	new Thread(() -> { 
		synchronized (obj) {
			log.debug("执行...."); 
			try {
				obj.wait(); // 让线程在obj上一直等待下去 
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			log.debug("其它代码...."); 
		}
	}).start();
	
	// 主线程两秒后执行
	sleep(2);
	log.debug("唤醒 obj 上其它线程"); 
	synchronized (obj) {
		obj.notify(); // 唤醒obj上一个线程
		// obj.notifyAll(); // 唤醒obj上所有等待线程 
	}
}

notify的一种结果

notifyAll的结果

• wait()方法会释放对象的锁，进入WaitSet等待区，从而让其他线程就有机会获取对象的锁。无限制等待，直到notify为止；
• wait(long n)有时限的等待，到n毫秒后结束等待，或是被notify

八、wait notify的正确姿势

sleep(long n)和wait(long n)的区别

• sleep是Thread方法，而wait是Object的方法；
• sleep不需要强制和synchronized配合使用，但wait需要和synchronized一起用
• sleep在睡眠的同时，不会释放对象锁的，但wait在等待的时候会释放对象锁
• 它们状态TIMED_WAITING

以下代码背景：一些线程为了线程安全，在获取到room对象后才可进行以下步骤

step1

 static final Object room = new Object(); 
 static boolean hasCigarette = false; 
 static boolean hasTakeout = false;

思考下面的解决方案好不好，为什么？

public static void main(String[] args) {
        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigarette);
                if (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    sleep(2);
                }
                log.debug("有烟没？[{}]", hasCigarette);
                if (hasCigarette) {
                    log.debug("可以开始干活了");
                }
            }
        }, "小南").start();

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                synchronized (room) {
                    log.debug("可以开始干活了");
                }
            }, "其它人").start();
        }

        sleep(1);
        new Thread(() -> {
            // 这里能不能加 synchronized (room)？
            synchronized (room) {
                hasCigarette = true;
                log.debug("烟到了噢！");
            }
        }, "送烟的").start();
    }

输出

• 其它干活的线程，都要一直阻塞，效率太低
• 小南线程必须睡足2s后才能醒来，就算烟提前送到，也无法立刻醒来
• 加了synchronized（room）后，就好比小南在里面反锁了门睡觉，烟根本没法送进门，main没加synchronized就好像main线程是翻窗户进来的
• 解决方法，使用wait - notify机制

step2

思考下面的实现行吗，为什么？

public static void main(String[] args) {
        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigarette);
                if (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    try {
                        room.wait(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("有烟没？[{}]", hasCigarette);
                if (hasCigarette) {
                    log.debug("可以开始干活了");
                }
            }
        }, "小南").start();

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                synchronized (room) {
                    log.debug("可以开始干活了");
                }
            }, "其它人").start();
        }

        sleep(1);
        new Thread(() -> {
            synchronized (room) {
                hasCigarette = true;
                log.debug("烟到了噢！");
                room.notify();
            }
        }, "送烟的").start();
    }

输出

• 解决了其它干活的线程阻塞的问题
• 但如果有其它线程在等待条件呢？

step3

// 虚假唤醒
    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigarette);
                if (!hasCigarette) {
                    log.debug("没烟，先歇会！");
                    try {
                        room.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("有烟没？[{}]", hasCigarette);
                if (hasCigarette) {
                    log.debug("可以开始干活了");
                } else {
                    log.debug("没干成活...");
                }
            }
        }, "小南").start();

        new Thread(() -> {
            synchronized (room) {
                Thread thread = Thread.currentThread();
                log.debug("外卖送到没？[{}]", hasTakeout);
                if (!hasTakeout) {
                    log.debug("没外卖，先歇会！");
                    try {
                        room.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                log.debug("外卖送到没？[{}]", hasTakeout);
                if (hasTakeout) {
                    log.debug("可以开始干活了");
                } else {
                    log.debug("没干成活...");
                }
            }
        }, "小女").start();

        sleep(1);
        new Thread(() -> {
            synchronized (room) {
                hasTakeout = true;
                log.debug("外卖到了噢！");
                room.notifyAll();
            }
        }, "送外卖的").start();
        
    }

输出

• notify只能随机唤醒一个WaitSet中的线程，这时如果有其它线程也在等待，那么就可能唤醒不了正确的的线程，称之为【虚假唤醒】
• 解决方法，改为notifyAll

step4

new Thread(() -> {
            synchronized (room) {
                hasTakeout = true;
                log.debug("外卖到了噢！");
                room.notifyAll();
            }
}, "送外卖的").start();

输出

• 用notifyAll仅解决某个线程的唤醒问题，但使用if + wait判断仅有一次机会，一旦条件不成立，就没有重新判断的机会了
• 解决方法，用while + wait，当条件不成立，再次wait

step5

将if改为while

if (!hasCigarette) {
        log.debug("没烟，先歇会！");
        try {
              room.wait();
        } catch (InterruptedException e) {
              e.printStackTrace();
        }
}

改动后

while (!hasCigarette) {
         log.debug("没烟，先歇会！");
         try {
               room.wait();
         } catch (InterruptedException e) {
                e.printStackTrace();
         }
}

输出

总结（根据以上五个例子）：

synchronized(lock) { 
	while(条件不成立) {
		lock.wait(); 
	}
	// 干活 
}

//另一个线程 
synchronized(lock) {
	lock.notifyAll(); 
}

模式之保护性暂停

1、定义

即Guarded Suspension，用在一个线程等待另一线程的执行结果。
要点：

• 有一个结果需要从一个线程传递到另一个线程，让他们关联同一个GuardedObject
• 如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）
• JDK中，join的实现，Future的实现，采用的就是此模式
• 因为要等待另一方的结果，因此归类到同步模式
  

2、实现

class GuardedObject { 

	private Object response;
	private final Object lock = new Object();
	
	public Object get() { 
		synchronized (lock) { 
			// 条件不满足则等待
			while (response == null) { 
				try {
					lock.wait();
				} catch (InterruptedException e) {
					e.printStackTrace(); 
				}
			}
			return response;
		}
	}
	 
	public void complete(Object response) { 
		synchronized (lock) {
			// 条件满足，通知等待线程 
			this.response = response; 
			lock.notifyAll();
		} 
	}
}

应用

一个线程等待另一个线程的执行结果

public static void main(String[] args) { 
	GuardedObject guardedObject = new GuardedObject(); 
	new Thread(() -> {
		try {
			// 子线程执行下载
			List<String> response = download(); 
			log.debug("download complete..."); 
			guardedObject.complete(response);
		} catch (IOException e) { 
			e.printStackTrace();} 
		}).start();
		
	log.debug("waiting...");
	// 主线程阻塞等待
	Object response = guardedObject.get();
	log.debug("get response: [{}] lines", ((List<String>) response).size());
}

执行结果

3、带潮湿版GuardedObject

如果要控制超时时间呢

class GuardedObjectV2 {

	private Object response;
	private final Object lock = new Object();
	
	public Object get(long millis) { 
		synchronized (lock) {
			// 1) 记录最初时间
			long begin = System.currentTimeMillis(); 
			// 2) 已经经历的时间
			long timePassed = 0;
			while (response == null) {
				// 4) 假设 millis 是 1000，结果在 400 时唤醒了，那么还有 600 要等 long waitTime = millis - timePassed;
				log.debug("waitTime: {}", waitTime);
				if (waitTime <= 0) {
					log.debug("break...");
					break; 
				}
				try { 
					lock.wait(waitTime);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// 3) 如果提前被唤醒，这时已经经历的时间假设为 400 
				timePassed = System.currentTimeMillis() - begin; 
				log.debug("timePassed: {}, object is null {}",
					timePassed, response == null); 
			}
			return response;
		} 
	}

	public void complete(Object response) { 
		synchronized (lock) {
			// 条件满足，通知等待线程 
			this.response = response; 
			log.debug("notify..."); 
			lock.notifyAll();
		} 
	}
}
   

测试，没有超时

public static void main(String[] args) { 
	GuardedObjectV2 v2 = new GuardedObjectV2(); 
	new Thread(() -> {
		sleep(1);
		v2.complete(null);
		sleep(1);
		v2.complete(Arrays.asList("a", "b", "c"));
	}).start();
	
	Object response = v2.get(2500);
	if (response != null) {
		log.debug("get response: [{}] lines", ((List<String>) response).size());
	} else {
		log.debug("can't get response");
	} 
}

输出

测试，超时

 // 等待时间不足
List<String> lines = v2.get(1500);

输出

join原理

是调用者轮询检查线程alive状态

t1.join();

等价于下面的代码

synchronized (t1) {
	// 调用者线程进入 t1 的 waitSet 等待, 直到 t1 运行结束 
	while (t1.isAlive()) {
		t1.wait(0); 
	}
}

注意：
join体现的是【保护性暂停】模式，请参考之

4、多任务版GuardedObject

1、图中Futures就好比居民楼一层的信箱（每个信箱有房间编号），左侧的t0，t2，t4就好比等待邮件的居民，右侧的t1，t3，t5就好比邮递员；
2、如果需要在多个类之间使用GuardedObject对象，作为参数传递不是很方便，因此设计一个用来接偶的中间类，这样不仅能够接偶【结果等待者】和【结果生产者】，还能够同时支持多个任务的管理。

新增id用来标识Guarded Object

// 增加超时效果
class GuardedObject {

    // 标识 Guarded Object
    private int id;

    public GuardedObject(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    // 结果
    private Object response;

    // 获取结果
    // timeout 表示要等待多久 2000
    public Object get(long timeout) {
        synchronized (this) {
            // 开始时间 15:00:00
            long begin = System.currentTimeMillis();
            // 经历的时间
            long passedTime = 0;
            while (response == null) {
                // 这一轮循环应该等待的时间
                long waitTime = timeout - passedTime;
                // 经历的时间超过了最大等待时间时，退出循环
                if (timeout - passedTime <= 0) {
                    break;
                }
                try {
                    this.wait(waitTime); // 虚假唤醒 15:00:01
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 求得经历时间
                passedTime = System.currentTimeMillis() - begin; // 15:00:02  1s
            }
            return response;
        }
    }

    // 产生结果
    public void complete(Object response) {
        synchronized (this) {
            // 给结果成员变量赋值
            this.response = response;
            this.notifyAll();
        }
    }
}

中间解耦类

class Mailboxes {
    private static Map<Integer, GuardedObject> boxes = new Hashtable<>();

    private static int id = 1;
    // 产生唯一 id
    private static synchronized int generateId() {
        return id++;
    }

    public static GuardedObject getGuardedObject(int id) {
        return boxes.remove(id);
    }

    public static GuardedObject createGuardedObject() {
        GuardedObject go = new GuardedObject(generateId());
        boxes.put(go.getId(), go);
        return go;
    }

    public static Set<Integer> getIds() {
        return boxes.keySet();
    }
}

业务相关类

@Slf4j(topic = "c.People")
class People extends Thread{
    @Override
    public void run() {
        // 收信
        GuardedObject guardedObject = Mailboxes.createGuardedObject();
        log.debug("开始收信 id:{}", guardedObject.getId());
        Object mail = guardedObject.get(5000);
        log.debug("收到信 id:{}, 内容:{}", guardedObject.getId(), mail);
    }
}

@Slf4j(topic = "c.Postman")
class Postman extends Thread {
    private int id;
    private String mail;

    public Postman(int id, String mail) {
        this.id = id;
        this.mail = mail;
    }

    @Override
    public void run() {
        GuardedObject guardedObject = Mailboxes.getGuardedObject(id);
        log.debug("送信 id:{}, 内容:{}", id, mail);
        guardedObject.complete(mail);
    }
}

测试

public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new People().start();
        }
        Sleeper.sleep(1);
        for (Integer id : Mailboxes.getIds()) {
            new Postman(id, "内容" + id).start();
        }
    }

某次运行结果：

模式之生产者消费者

1、定义

要点：

• 与前面的保护性暂停中的GuardObject不同，不需要产生结果和消费结果的线程一一对应
• 消费队列可以用来平衡生产和消费的线程资源
• 生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据
• 消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据
• JDK中各种阻塞队列，采用的就是这种模式。
  

2、实现

// 消息队列类 ， java 线程之间通信
@Slf4j(topic = "c.MessageQueue")
class MessageQueue {
    // 消息的队列集合
    private LinkedList<Message> list = new LinkedList<>();
    // 队列容量
    private int capcity;

    public MessageQueue(int capcity) {
        this.capcity = capcity;
    }

    // 获取消息
    public Message take() {
        // 检查队列是否为空
        synchronized (list) {
            while(list.isEmpty()) {
                try {
                    log.debug("队列为空, 消费者线程等待");
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 从队列头部获取消息并返回
            Message message = list.removeFirst();
            log.debug("已消费消息 {}", message);
            list.notifyAll();
            return message;
        }
    }

    // 存入消息
    public void put(Message message) {
        synchronized (list) {
            // 检查对象是否已满
            while(list.size() == capcity) {
                try {
                    log.debug("队列已满, 生产者线程等待");
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 将消息加入队列尾部
            list.addLast(message);
            log.debug("已生产消息 {}", message);
            list.notifyAll();
        }
    }
}

final class Message {
    private int id;
    private Object value;

    public Message(int id, Object value) {
        this.id = id;
        this.value = value;
    }

    public int getId() {
        return id;
    }

    public Object getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", value=" + value +
                '}';
    }
}

3、应用

public static void main(String[] args) {
        MessageQueue queue = new MessageQueue(2);

        for (int i = 0; i < 3; i++) {
            int id = i;
            new Thread(() -> {
                queue.put(new Message(id , "值"+id));
            }, "生产者" + i).start();
        }

        new Thread(() -> {
            while(true) {
                sleep(1);
                Message message = queue.take();
            }
        }, "消费者").start();
    }

其次运行结果：

九、Park & Unpark

每个线程都有自己的一个Parker对象，由三部分组成_counter,_cond,_mutex打个比喻

• 线程就像一个旅人，Parker就像他随身携带的背包，条件变量就好比背包中的帐篷。_counter就好比背包中的备用干粮（0为耗尽，1为充足）

• 调用park就是要看需不需要停下来歇息
  – 如果备用干粮耗尽，那么钻进帐篷歇息
  – 如果备用干粮充足，那么不需停留，继续前进

• 调用unpark，就好比令干粮充足
  – 如果这时线程还在帐篷，就唤醒让他继续前进
  – 如果这时线程还在运行，那么下次他调用park时，仅是消耗掉备用干粮，不需停留继续前进
  （因为背包空间有限，多次调用unpark仅会补充一份备用干粮）

一、先调用unpark然后调用park执行流程
1、当前线程调用Unsafe.park()方法
2、检查_counter,本情况为0，这时，获得_mutex互斥锁
3、线程进入_cond条件变量阻塞
4、设置_counter = 0

1、调用Unsafe.unpark（Thread_0）方法，设置_counter为1
2、唤醒_cond条件变量中的Thread_0
3、Thread_0恢复运行
4、设置_counter为0

二、先调用park然后调用unpark执行流程
1、调用 Unsafe.unpark(Thread_0) 方法，设置 _counter 为 1
2、当前线程调用 Unsafe.park() 方法
3、检查 _counter ，本情况为 1，这时线程无需阻塞，继续运行
4、设置 _counter 为 0

十、重新理解线程状态转换

假设有线程Thread t

情况1 NEW -->. RUNNABLE

• 当调用t.start()方法时，由NEW --> RUNNABLE

情况2 RUNNABLE < – > WAITING
t 线程用synchronized(obj)获取了对象锁后

• 调用obj.wait()方法时，t线程从RUNNABLE --> WAITING
• 调用obj.notify()，obj.notifyAll()，t.interrupt()时
  – 竞争锁成功，t 线程从WAITING --> RUNNABLE
  – 竞争锁失败，t 线程从WAITING --> BLOCKED

public class TestWaitNotify {
    final static Object obj = new Object();

    public static void main(String[] args) {

        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行....");
                try {
                    obj.wait(); // 让线程在obj上一直等待下去
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其它代码....");  //断点
            }
        },"t1").start();

        new Thread(() -> {
            synchronized (obj) {
                log.debug("执行....");
                try {
                    obj.wait(); // 让线程在obj上一直等待下去
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("其它代码...."); //断点
            }
        },"t2").start();

        // 主线程两秒后执行
        sleep(0.5);
        log.debug("唤醒 obj 上其它线程");
        synchronized (obj) {
//            obj.notify(); // 唤醒obj上一个线程
            obj.notifyAll(); // 唤醒obj上所有等待线程  断点
        }
    }
}

情况3 RUNNABLE --> WAITING

• 当前线程调用t.join()方法时，当前线程从RUNNABLE --> WAITING
  – 注意是当前线程在t 线程对象的监视器上等待

• t 线程运行结束，或调用了当前线程的interrupt()时，当前线程从WAITING --> RUNNABLE

情况 4 RUNNABLE <--> WAITING

• 当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING
• 调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，会让目标线程从 WAITING --> RUNNABLE

情况 5 RUNNABLE <--> TIMED_WAITING
t 线程用 synchronized(obj) 获取了对象锁后

• 调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED_WAITING
• t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
  – 竞争锁成功，t 线程从 TIMED_WAITING --> RUNNABLE
  – 竞争锁失败，t 线程从 TIMED_WAITING --> BLOCKED

情况 6 RUNNABLE <--> TIMED_WAITING

• 当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED_WAITING
  – 注意是当前线程在t 线程对象的监视器上等待
• 当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 TIMED_WAITING --> RUNNABLE

情况 7 RUNNABLE <--> TIMED_WAITING

• 当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE --> TIMED_WAITING
• 当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE

情况 8 RUNNABLE <--> TIMED_WAITING

• 当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线 程从 RUNNABLE --> TIMED_WAITING
• 调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，或是等待超时，会让目标线程从TIMED_WAITING--> RUNNABLE

情况 9 RUNNABLE <--> BLOCKED

• t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从 RUNNABLE --> BLOCKED
• 持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争 成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED

情况 10 RUNNABLE <--> TERMINATED
当前线程所有代码运行完毕，进入 TERMINATED

十一、多把锁

多把不相干的锁

• 一间大屋子有两个功能：睡觉、学习、互不相干；
• 现在小南要学习，小女要睡觉，但如果只用一间屋子（一个对象锁）的话，那么并发度很低
• 解决方法是准备多个房间（多个对象锁）

例如

class BigRoom {
	public void sleep() { 
		synchronized (this) {
			log.debug("sleeping 2 小时");
			Sleeper.sleep(2); 
		}
	}
	
	public void study() { 
		synchronized (this) {
			log.debug("study 1 小时");
			Sleeper.sleep(1); 
		}
	} 
}

执行

BigRoom bigRoom = new BigRoom(); 
new Thread(() -> {
	bigRoom.compute(); 
},"小南").start();
new Thread(() -> {
	bigRoom.sleep(); 
},"小女").start();

其次结果

改进

class BigRoom {
	private final Object studyRoom = new Object();
	private final Object bedRoom = new Object(); 
	public void sleep() {
		synchronized (bedRoom) { 
			log.debug("sleeping 2 小时"); Sleeper.sleep(2);
		} 
	}
	
	public void study() { 
		synchronized (studyRoom) {
			log.debug("study 1 小时");
			Sleeper.sleep(1); 
		}
	} 
}

某次执行结果

将锁的粒度细分

• 好处：是可以增强并发度
• 坏处：如果一个线程需要同时获得多把锁，就容易发生死锁

十二、活跃性

1、死锁

1、有这样的情况：一个线程需要同时获取多把锁，这时就容易发生死锁
2、t1 线程获得 A对象锁，接下来想获取B对象的锁 t2 线程获得B对象锁，接下来想获取A对象的锁 例：

Object A = new Object(); 
Object B = new Object(); 
Thread t1 = new Thread(() -> {
	synchronized (A) { 
		log.debug("lock A"); sleep(1); 
		synchronized (B) {
			log.debug("lock B");
			log.debug("操作..."); 
		}
	}
}, "t1");

Thread t2 = new Thread(() -> { 
	synchronized (B) {
		log.debug("lock B"); sleep(0.5);
		synchronized (A) {
			log.debug("lock A");
			log.debug("操作..."); 
		}
	}
}, "t2");
t1.start(); 
t2.start();

结果：

2、定位死锁

检测死锁可以使用jconsole工具，或者使用jps定位进程id，再用jstack定位死锁：

• 避免死锁要注意加锁顺序
• 另外如果由于某个线程进入了死循环，导致其它线程一直等待，对于这种情况linux下可以通过top先定位到CPU占用高的Java线程，再利用top -Hp 进程id来定位是哪个线程，最后再用jstack排查

3、哲学家就餐问题

有五位哲学家，围坐在圆桌旁。

• 他们只做两件事，思考和吃饭，思考一会吃口饭，吃完饭后接着思考；
• 吃饭时要用两根筷子吃，桌子共有5根筷子，每位哲学家左右手边各有一根筷子；
• 如果筷子被身边的人拿着，自己就得等待；

筷子类

class Chopstick { 
	String name;
	
	public Chopstick(String name) { 
		this.name = name;
	}
	
	@Override
	public String toString() { 
		return "筷子{" + name + '}';
	}
}

哲学家类

class Philosopher extends Thread { 
	Chopstick left;
	Chopstick right;
	public Philosopher(String name, Chopstick left, Chopstick right) {
		super(name);
		this.left = left;
		this.right = right; 
	}
	
	private void eat() { 
		log.debug("eating..."); 
		Sleeper.sleep(1);
	}
	
	@Override
	public void run() { 
		while (true) {
			// 获得左手筷子 
			synchronized (left) {
				// 获得右手筷子 
				synchronized (right) {
					// 吃饭
					eat(); 
				}
			// 放下右手筷子 
			}
		// 放下左手筷子 
		}
	} 
}

就餐

Chopstick c1 = new Chopstick("1");
Chopstick c2 = new Chopstick("2");
Chopstick c3 = new Chopstick("3");
Chopstick c4 = new Chopstick("4");
Chopstick c5 = new Chopstick("5");
new Philosopher("苏格拉底", c1, c2).start(); 
new Philosopher("柏拉图", c2, c3).start(); 
new Philosopher("亚里士多德", c3, c4).start(); 
new Philosopher("赫拉克利特", c4, c5).start(); 
new Philosopher("阿基米德", c5, c1).start();

执行不多会，就执行不下去了

使用jconsole检测死锁，发现：

这种线程没有按照预期结束，执行不下去的情况，归类为【活跃性】问题，除了死锁以外，还有死锁和饥饿者两种情况

4、活锁

活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束，例如

public class TestLiveLock {
	static volatile int count = 10;
	static final Object lock = new Object();
	public static void main(String[] args) {
		new Thread(() -> {
			// 期望减到 0 退出循环 
			while (count > 0) { 
				sleep(0.2);
				count--;
				log.debug("count: {}", count); }
			}, "t1").start();
			
		new Thread(() -> {
			// 期望超过 20 退出循环 
			while (count < 20) { 
				sleep(0.2);
				count++;
				log.debug("count: {}", count); 
			}
		}, "t2").start(); 
	}
}
 

5、饥饿

• 很多教程中把饥饿定义为，一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束，饥饿的情况不 易演示，讲读写锁时会涉及饥饿问题
• 下面我讲一下我遇到的一个线程饥饿的例子，先来看看使用顺序加锁的方式解决之前的死锁问题

顺序加锁的解决方案

十三、ReentrantLock

相对于synchronized它具备如下特点

• 可中断
• 可以设置超时时间
• 可以设置为公平锁
• 支持多个条件变量

与synchronized一样，都支持可重入

基本语法

1、可重入

• 可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁；
• 如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住

static ReentrantLock lock = new ReentrantLock();

public static void main(String[] args) { 
	method1();
}
public static void method1() { 
	lock.lock();
	try {
		log.debug("execute method1"); 
		method2();
	} finally { 
		lock.unlock();
	} 
}

public static void method2() { 
	lock.lock();
	try {
		log.debug("execute method2"); 
	method3();
	} finally { 
		lock.unlock();
	} 
}

public static void method3() { 
	lock.lock();
	try {
		log.debug("execute method3");
	} finally { 
		lock.unlock();
	} 
}

输出：

2、可打断

示例：

ReentrantLock lock = new ReentrantLock(); 
Thread t1 = new Thread(() -> {
	log.debug("启动..."); 
	try {
		lock.lockInterruptibly();
	} catch (InterruptedException e) {
		e.printStackTrace(); 
		log.debug("等锁的过程中被打断"); 
		return;
	} try {
		log.debug("获得了锁"); 
	} finally {
		lock.unlock(); 
	}
}, "t1");

lock.lock(); 
log.debug("获得了锁"); 
t1.start();
try {
	sleep(1); 
	t1.interrupt(); 
	log.debug("执行打断");
} finally { 
	lock.unlock();
}

输出：

注意如果是不可中断模式，那么即使使用了interrupt也不会让等待中断

ReentrantLock lock = new ReentrantLock();
	Thread t1 = new Thread(() -> { 
		log.debug("启动...");
		lock.lock(); try {
		log.debug("获得了锁"); 
		} finally {
			lock.unlock(); 
		}
	}, "t1");

lock.lock(); 
log.debug("获得了锁"); 
t1.start();
try {
	sleep(1); 
	t1.interrupt(); 
	log.debug("执行打断"); 
	sleep(1);
} finally { 
	log.debug("释放了锁"); 
	lock.unlock();
}

输出：

3、锁超时

立刻失败

ReentrantLock lock = new ReentrantLock(); 
Thread t1 = new Thread(() -> {
	log.debug("启动..."); 
	if (!lock.tryLock()) {
		log.debug("获取立刻失败，返回");
		return; 
	}
	try { 
		log.debug("获得了锁");
	} finally { 
		lock.unlock();
	}
}, "t1");

lock.lock(); 
log.debug("获得了锁");
t1.start(); 
try {
	sleep(2); 
} finally {
	lock.unlock(); 
}

输出：

超时失败

ReentrantLock lock = new ReentrantLock(); 
Thread t1 = new Thread(() -> {
	log.debug("启动..."); 
	try {
		if (!lock.tryLock(1, TimeUnit.SECONDS)) { 
			log.debug("获取等待 1s 后失败，返回"); 
			return;
		}
	} catch (InterruptedException e) {
		e.printStackTrace(); 
	}
	try { 
		log.debug("获得了锁");
	} finally { 
		lock.unlock();
	}
}, "t1");

lock.lock(); 
log.debug("获得了锁"); 
t1.start();
try {
	sleep(2); 
} finally {
	lock.unlock(); 
}

输出：

使用tryLock解决哲学家就餐问题

class Chopstick extends ReentrantLock { 
	String name;
	
	public Chopstick(String name) { 
		this.name = name;
	}
	@Override
	public String toString() { 
		return "筷子{" + name + '}';
	} 
}

class Philosopher extends Thread { 
	Chopstick left;
	Chopstick right;
	
	public Philosopher(String name, Chopstick left, Chopstick right) { 
		super(name);
		this.left = left;
		this.right = right; 
	}
	@Override
	public void run() {
		 while (true) {
			// 尝试获得左手筷子
			if (left.tryLock()) {
				try {
					// 尝试获得右手筷子
					if (right.tryLock()) {
						try { 
							eat();
						} finally { 
							right.unlock();
						} 
					}
				} finally { 
					left.unlock();
				} 
			}
		} 
	}
	
	private void eat() { 
		log.debug("eating..."); 
		Sleeper.sleep(1);
	} 
}

4、公平锁

ReentrantLock默认是不公平的

ReentrantLock lock = new ReentrantLock(false);

lock.lock();
for (int i = 0; i < 500; i++) {
	new Thread(() -> { 
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + " running...");
		} finally { 
			lock.unlock();
		}
	}, "t" + i).start();
}

// 1s 之后去争抢锁 
Thread.sleep(1000); new Thread(() -> {
	System.out.println(Thread.currentThread().getName() + " start..."); lock.lock();
	try {
		System.out.println(Thread.currentThread().getName() + " running..."); } finally {
		lock.unlock(); 
	}
}, "强行插入").start(); 
lock.unlock();

强行插入，有机会在中间输出

注意：该实验不一定总能复现

改为公平锁后

 ReentrantLock lock = new ReentrantLock(true);

强行插入，总是在最后输出

公平锁一般没有必要，会降低并发度，后面分析原理时会讲解

5、条件变量

• synchronized中也有条件变量，就是我们讲原理时那个waitSet休息室，当条件不满足时进入waitSet等待；
• ReetrantLock的条件变量比synchronized强大之处在于，它是支持多个条件变量的，这就好比
  – synchronized是那些不满足条件的线程都在一间休息室等消息
  – 而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤 醒

使用要点:

• await 前需要获得锁
• await 执行后，会释放锁，进入 conditionObject 等待
• await 的线程被唤醒(或打断、或超时)取重新竞争 lock 锁
• 竞争 lock 锁成功后，从 await 后继续执行

例子

static ReentrantLock lock = new ReentrantLock();
static Condition waitCigaretteQueue = lock.newCondition(); 
static Condition waitbreakfastQueue = lock.newCondition(); 
static volatile boolean hasCigrette = false;
static volatile boolean hasBreakfast = false;

public static void main(String[] args) { 
	new Thread(() -> {
		try { 
			lock.lock();
			while (!hasCigrette) {
				try { 
					waitCigaretteQueue.await();
				} catch (InterruptedException e) { 
					e.printStackTrace();
				} 
			}
			log.debug("等到了它的烟"); 
		} finally {
			lock.unlock(); 
		}
	}).start();
	
	new Thread(() -> { 
		try {
			lock.lock();
			while (!hasBreakfast) {
				try { 
					waitbreakfastQueue.await();
				} catch (InterruptedException e) { 
					e.printStackTrace();
				} 
			}
			log.debug("等到了它的早餐"); 
		} finally {
			lock.unlock(); 
		}
	}).start();
	sleep(1); 
	sendBreakfast(); 
	sleep(1); 
	sendCigarette();
}

private static void sendCigarette() { 
	lock.lock();
	try {
		log.debug("送烟来了"); 
		hasCigrette = true; 
		waitCigaretteQueue.signal();
	} finally { 
		lock.unlock();
	} 
}

private static void sendBreakfast() { 
	lock.lock();
	try {
		log.debug("送早餐来了"); 
		hasBreakfast = true; 
		waitbreakfastQueue.signal();
	} finally { 
		lock.unlock();
	}
}

输出

6、同步模式之顺序控制

1、固定运行顺序

比如，必须先2后1打印

1.1 wait notify版

// 用来同步的对象
static Object obj = new Object(); 
// t2 运行标记， 代表 t2 是否执行过 
static boolean t2runed = false;

public static void main(String[] args) {

Thread t1 = new Thread(() -> { 
	synchronized (obj) {
	// 如果 t2 没有执行过 
		while (!t2runed) {
			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(); 
}

1.2 park Unpark版

可以看到，实现上很麻烦:

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

可以使用 LockSupport 类的 park 和 unpark 来简化上面的题目:

Thread t1 = new Thread(() -> {
	try { Thread.sleep(1000); } catch (InterruptedException e) { }
	// 当没有『许可』时，当前线程暂停运行;有『许可』时，用掉这个『许可』，当前线程恢复运行 
	LockSupport.park();
	System.out.println("1");
});
Thread t2 = new Thread(() -> {
	System.out.println("2");
	// 给线程 t1 发放『许可』(多次连续调用 unpark 只会发放一个『许可』) 
	LockSupport.unpark(t1);
});

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

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

2、交替输出

线程 1 输出 a 5 次，线程 2 输出 b 5 次，线程 3 输出 c 5 次。现在要求输出 abcabcabcabcabc 怎么实现

2.1 wait notify版本

class SyncWaitNotify { 
	private int flag; 
	private int loopNumber;

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

SyncWaitNotify syncWaitNotify = new SyncWaitNotify(1, 5); 
new Thread(() -> {
	syncWaitNotify.print(1, 2, "a"); 
}).start();
new Thread(() -> { 
	syncWaitNotify.print(2, 3, "b");
}).start();
new Thread(() -> {
	syncWaitNotify.print(3, 1, "c"); 
}).start();

2.2 Lock条件变量版

class AwaitSignal extends ReentrantLock { 
	public void start(Condition first) {
		this.lock();
		try { 
			log.debug("start"); 
			first.signal();
		} finally { 
			this.unlock();
		} 
	}
	public void print(String str, Condition current, Condition next) { 
		for (int i = 0; i < loopNumber; i++) {
			this.lock(); 
			try {
				current.await(); 
				log.debug(str); 
				next.signal();
			} catch (InterruptedException e) { 
				e.printStackTrace();
			} finally { 
				this.unlock();
			} 
		}
	}

	// 循环次数
	private int loopNumber;
	public AwaitSignal(int loopNumber) { 
		this.loopNumber = loopNumber;
	} 
}

AwaitSignal as = new AwaitSignal(5); 
Condition aWaitSet = as.newCondition(); 
Condition bWaitSet = as.newCondition(); 
Condition cWaitSet = as.newCondition();

new Thread(() -> {
	as.print("a", aWaitSet, bWaitSet);
}).start();
new Thread(() -> {
	as.print("b", bWaitSet, cWaitSet); 
}).start();
new Thread(() -> {
	as.print("c", cWaitSet, aWaitSet);
}).start(); 

as.start(aWaitSet);

注意：
该实现没有考虑a，b，c线程都就绪再开始

2.3 Park Unpark版

class SyncPark {
	private int loopNumber; 
	private Thread[] threads;
	
	public SyncPark(int loopNumber) { 
		this.loopNumber = loopNumber;
	}
	public void setThreads(Thread... threads) { 
		this.threads = threads;
	}
	public void print(String str) {
		for (int i = 0; i < loopNumber; i++) {
			LockSupport.park(); System.out.print(str); 
			LockSupport.unpark(nextThread());
		} 
	}
	private Thread nextThread() {
		Thread current = Thread.currentThread(); 
		int index = 0;
		for (int i = 0; i < threads.length; i++) {
			if(threads[i] == current) { 
				index = i;
				break; 
			}
		}
		if(index < threads.length - 1) {
			return threads[index+1]; 
		} else {
			return threads[0]; 
		}
	}
	public void start() {
		for (Thread thread : threads) {
			thread.start(); 
		}
		LockSupport.unpark(threads[0]); 
	}
}
	
	
SyncPark syncPark = new SyncPark(5); 
Thread t1 = new Thread(() -> {
	syncPark.print("a"); 
});
Thread t2 = new Thread(() -> { 
	syncPark.print("b");
});
Thread t3 = new Thread(() -> {
	syncPark.print("c\n"); 
});
syncPark.setThreads(t1, t2, t3); 

syncPark.start();

十四、小结

本章我们需要重点掌握的是

• 分析多线程访问共享资源时，哪些代码片段属于临界区
• 使用 synchronized 互斥解决临界区的线程安全问题
  – 掌握 synchronized 锁对象语法
  – 掌握 synchronzied 加载成员方法和静态方法语法
  – 掌握 wait/notify 同步方法
• 使用 lock 互斥解决临界区的线程安全问题
  – 掌握 lock 的使用细节:可打断、锁超时、公平锁、条件变量
• 学会分析变量的线程安全性、掌握常见线程安全类的使用
• 了解线程活跃性问题:死锁、活锁、饥饿
• 应用方面
  – 互斥:使用 synchronized 或 Lock 达到共享资源互斥效果
  – 同步:使用 wait/notify 或 Lock 的条件变量来达到线程间通信效果
• 原理方面
  – monitor、synchronized 、wait/notify 原理
  – synchronized 进阶原理
  – park & unpark 原理
• 模式方面
  – 同步模式之保护性暂停
  – 异步模式之生产者消费者
  – 同步模式之顺序控制