ReentrantLock 练习

/**
 * aa 打印5次， bb打印10次， cc打印15次
 * 紧接着，
 * aa 打印5次， bb打印10次， cc打印15次
 * ......
 * 来10轮
 */

SyncAndReentrantLockTest.java

class ShareResourceTest {
    private int number = 1;

    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void printAll(int num) throws InterruptedException {
        lock.lock();
        int isNum = 1;
        Condition awaitCondition = null;
        Condition signalCondition = null;
        if(5 == num){
            isNum = 1;
            awaitCondition = c1;
            signalCondition = c2;
        }
        if (10 == num) {
            isNum = 2;
            awaitCondition = c2;
            signalCondition = c3;
        }
        if (15 == num) {
            isNum = 3;
            awaitCondition = c3;
            signalCondition = c1;
        }
        while (number != isNum) {
            awaitCondition.await();
        }
        // 干活
        for (int i = 1; i <= num; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        // 通知
        if (isNum == 3) {
            isNum = 0;
        }
        number = isNum + 1;
        signalCondition.signal();
        lock.unlock();
    }
}

public class SyncAndReentrantLockTest {
    public static void main(String[] args) {
        ShareResourceTest shareResource = new ShareResourceTest();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    shareResource.printAll(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "aa").start();

        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    shareResource.printAll(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "bb").start();

        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                try {
                    shareResource.printAll(15);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "cc").start();
    }
}

备注： 来自一个优秀的男人，周老师。

解释:

* 1. synchronized 关键字属于jvm层面。 底层使用 monitorexit 释放。 
* 		lock是具体类，是api层面的锁。
* 2. 使用方法
* 		synchronized 不需要用户手动释放。代码执行完后系统会自动让线程释放对锁的占用。
* 		ReentrantLock 则需要用户手动释放，若没有主动释放锁，就可能导致出现死锁。需要 myself.lock() unlock() 方法，配合 try/finally语句块来完成。
* 3. 等待是否可中断。
* 		synchronized 不可中断， 除非抛出异常或者正常运行完成。
* 		ReentrantLock 可中断。 1. 设置超时方法。tryLock(long timeout, TimeUnit unit)
* 2. lockInterruptibly() 方代码块中，调用 interrupt() 方法可中断。
* 4. 加锁是否公平。
* 		synchronized 非公平锁。
* 		ReentrantLock 两者都可以。默认非公平锁。构造方法可以传入boolean值，true为公平锁，false为非公平锁。
* 5. 锁绑定多个条件condition
* 		synchronized 没有。
* 		ReentrantLock 用来实现分组唤醒需要唤醒的线程，可以精确唤醒，而不是像 synchronized 要么随机唤醒一个线程，要么唤醒全部线程。