【进阶】- Lock Condition

并发编程领域，两大核心问题：
一个是互斥：即同一时刻只允许一个线程访问共享资源；
另一个是同步：即线程间如何通信、协助；

这两大问题，管程都能够解决。
Java SDK并发包通过Lock和Condition两个接口来实现管程，其实Lock用于解决互斥问题，Condition解决同步问题。

Lock存在理由

有Synchronized，还要有Lock、Condition的理由
原因是Synchronized申请资源的时候，如果申请不到，线程直接进入阻塞状态，而线程进入阻塞状态，啥都干不了，也释放不了线程已经占用的资源。

重新互斥锁去解决这个问题，要求

1. 能够响应中断。
   synchronized 的问题是，持有锁 A 后，如果尝试获取锁 B 失败，那么线程就进入阻塞状态，一旦发生死锁，就没有任何机会来唤醒阻塞的线程。但如果阻塞状态的线程能够响应中断信号，也就是说当我们给阻塞的线程发送中断信号的时候，能够唤醒它，那它就有机会释放曾经持有的锁 A。这样就破坏了不可抢占条件了
2. 支持超时。
   如果线程在一段时间之内没有获取到锁，不是进入阻塞状态，而是返回一个错误，那这个线程也有机会释放曾经持有的锁。这样也能破坏不可抢占条件。
3. 非阻塞地获取锁。
   如果尝试获取锁失败，并不进入阻塞状态，而是直接返回，那这个线程也有机会释放曾经持有的锁。这样也能破坏不可抢占条件。

Lock

public interface Lock {

    void lock();

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

    Condition newCondition();
}

Condition

public interface Condition {

    void await() throws InterruptedException;

    void awaitUninterruptibly();

    long awaitNanos(long nanosTimeout) throws InterruptedException;

    boolean await(long time, TimeUnit unit) throws InterruptedException;

    boolean awaitUntil(Date deadline) throws InterruptedException;

    void signal();

    void signalAll();
}

消费者，生产者 Demo

public class Ticket {

    private static ReentrantLock lock = new ReentrantLock();

    static Condition condition = lock.newCondition();

    static int ticket = 0;

    public static void buyTicket() {
        while (true) {
            lock.lock();
            try {
                if (ticket > 0) {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("买票 剩余票数" + --ticket);

                    condition.signalAll();
                } else {
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            } finally {
                lock.unlock();
            }
        }
    }

    public static void productTicket() {
        while (true) {
            lock.lock();
            try {
                if (ticket < 10) {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("生产，目前票数 " + ++ticket);

                    condition.signalAll();
                } else {
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } finally {
                lock.unlock();
            }
        }
    }
}