leetcode1115. 交替打印 FooBar

题目

1115. 交替打印 FooBar

给你一个类：

class FooBar {
  public void foo() {
    for (int i = 0; i < n; i++) {
      print("foo");
    }
  }

  public void bar() {
    for (int i = 0; i < n; i++) {
      print("bar");
    }
  }
}

两个不同的线程将会共用一个 FooBar 实例：

线程 A 将会调用 foo() 方法，而
线程 B 将会调用 bar() 方法
请设计修改程序，以确保 “foobar” 被输出 n 次。

示例 1：

输入：n = 1
输出：“foobar”
解释：这里有两个线程被异步启动。其中一个调用 foo() 方法, 另一个调用 bar() 方法，“foobar” 将被输出一次。

示例 2：

输入：n = 2
输出：“foobarfoobar”
解释：“foobar” 将被输出两次。

提示：

1 <= n <= 1000

解析思路

需要有一个变量控制两个线程进行交替打印，即必须是先foo，然后bar，再然后foo，再然后bar…（不能foo函数还没执行就先执行bar函数，或者foo函数一直执行）
那么就可以用类似锁的思路去实现，并且这个锁要区分两种不同类型的线程，既可以理解成此题是一个变种的“消费者-生产者”问题。
java中，可以用Lock中的Condition来实现。

前置知识

• ReentrantLock是实现了Lock接口的类，它是通过CAS+AQS来实现的。
• 当前线程执行ReentrantLock对象的lock()方法，如果获取锁成功，则ReentrantLock对象中的state+1，在该线程没释放该锁之前其他线程不能重复获取该ReentrantLock对象的锁，会被阻塞放入到ReentrantLock的阻塞队列中（这个队列是一个双向链表构成的，线程会被包装成一个Node对象插入这个双向链表中）
• 而ReentrantLock还有一个等待队列，当前获取锁的线程执行Condition的await()方法时会将当前线程加入到ReentrantLock对象的等待队列中。并且此时会自动释放掉获取的锁，其他在阻塞队列中的线程可以抢夺锁了。（等待队列是单项链表构成，但是跟synchronized的monitor中的等待队列相比（一个monitor对象只能有一个等待队列），一个condition的等待队列可以有多个等待队列）

ReentrantLock的原理内附一个通过ReentrantLock以及Condition实现的生产者-消费者实例代码。
ReentrantLock的Condition实现原理
添加链接描述

代码

private int n;
Lock lock = new ReentrantLock();
Condition conFoo = lock.newCondition();
boolean flag = false;
public FooBar(int n) {
    this.n = n;
}

public void foo(Runnable printFoo) throws InterruptedException {
    for (int i = 0; i < n; i++) {
        lock.lock();
        try
        {
            while(flag){
                conFoo.await();
            }
            // printFoo.run() outputs "foo". Do not change or remove this line.
            printFoo.run();
            conFoo.signal();
            flag = true;
        }catch(InterruptedException ie){
            ie.printStackTrace();
        }finally{
            lock.unlock();
        }
       
    }
}

public void bar(Runnable printBar) throws InterruptedException {
    for (int i = 0; i < n; i++) {
        lock.lock();
        try{
            while(!flag){
                conFoo.await();
            }
            // printBar.run() outputs "bar". Do not change or remove this line.
    	    printBar.run();
            conFoo.signal();
            flag = false;
        }catch(InterruptedException ie){
            ie.printStackTrace();
        }finally{
            lock.unlock();
        }
        
    }
}

注意点

1.当前线程获取ReentrantLock对象的锁后，如果执行Condition的await方法，被阻塞时，会自动释放当前的锁。其他在阻塞队列中的线程会被唤醒，去争夺锁。

2.ReentrantLock对象获取锁的lock()方法要写在try…catch之外，而释放锁的unlock()方法要写在finally中。

原因：

• 加入lock()写在try…catch之内，如下

try{
		lock.lock()
	    if(!flag){
	        conFoo.await();
	    }
	    // printBar.run() outputs "bar". Do not change or remove this line.
		printBar.run();
	   	conFoo.signal();
	   	flag = false;
	}
catch(InterruptedException ie){
    ie.printStackTrace();
}
finally{
   lock.unlock();
}

那么如果lock()方法执行异常，最终会执行finally的unlock()方法，但是当前线程又没有对ReentrantLock加锁成功，则会报错IllegalStateException。

• 释放锁unlock()方法要写在finally中是因为，如果unlock()方法直接放在try代码块中的最后，如果方法块执行中其他代码出现异常，就不会执行unlock()方法，则这个锁就永远不会被释放，产生死锁了。

3.throws InterrruptedException是Condition对象的await操作抛出的，不是ReentrantLock对象执行lock()方法抛出的。

4.这里判断flag是否为true的逻辑是用while的，而不是用if，

是防止出现提前执行signal，让其他等待队列中不应该释放的线程被提前释放。
并且当满足条件时即跳出循环，比if也不会造成效率的浪费。