1、前言

java.util.concurrent.locks为锁定和等待条件提供一个框架的接口和类，说白了就是锁所在的包。

2、什么是Lock

Lock是一种锁机制，比同步块（synchronized block）更加灵活，同时也更加复杂的线程同步机制。在JDK1.5就已存在Lock接口了。

其中有三个实现类：

ReentrantLock：可重入锁
ReentrantReadWriteLock.ReadLock：读锁
ReentrantReadWriteLock.WriteLock：写锁

3、Lock的API

Lock接口只提供了6个方法：

其中lock()和unlock()是配对的。lock()是加锁，而unlock()是解锁。lockInterruptibly()与lock()类似，区别在于lock()如果无法获取到锁，线程一直被阻塞，直到锁释放。而lockInterruptibly()允许线程被中断，并抛出java.lang.InterruptedException。

tryLock()只有在调用时才可以获得锁。如果可用，则获取锁定，并返回true，反之返回false。相应的还有重载方法tryLock(long time, TimeUnit unit)表示在给定的等待时间内空闲，则可以获取锁。如果到了超时时间，还没获取到就放弃获取。

4、ReentrantLock的基本使用

Lock是一个接口，官方文档其实也给了如何使用的说明：

声明Lock对象。Lock lock = new XXXLock();
方法执行加锁lock.lock();
在方法块执行完毕后，需要释放锁：lock.unlock();

由于LocK是一个接口，需要使用具体的实现。典型的实现如ReentrantLock。示例代码如下：

public class ReentrantLockDemo {

    public static void main(String[] args) {
        Phones phones = new Phones();

        new Thread(() -> {
            for(int i = 0; i< 50; i++) {
                phones.sale();
            }
        }, "销售员小王").start();

        new Thread(() -> {
            for(int i = 0; i< 50; i++) {
                phones.sale();
            }
        }, "销售员小红").start();
    }

}

class Phones {
    // 库存10部手机
    private int total = 50;

    // 1、 声明锁的实例
    ReentrantLock lock = new ReentrantLock();

    public void sale(){
        try {
            // 2、加锁，代码规约检测会提示你加载try的第一行
            lock.lock();
            if(total > 0){
                System.out.println(Thread.currentThread().getName() + "卖出了一部手机，当前库存剩余：" + (--total));
            }
        } finally {
            // 3、释放锁
            lock.unlock();
        }
    }
}

执行结果：

ReentrantLock是个可重入锁，其中可以执行公平锁和非公平锁。如new ReentrantLock(true)，默认是非公平锁（false）。

4.1、公平锁和非公平锁

公平锁：每个线程获取锁的顺序按照先后顺序获取。关键字眼：先到先得。
- 优点：能保证所有的线程都得到资源，不会产生线程饥饿现象。
- 缺点：吞吐量低，除了第一个线程以外，其余的都处于排队阻塞的状态，cpu需要每次唤醒线程，开销较大。
非公平锁：多个线程同时尝试获取，哪个线程优先获取到锁取决于系统分配策略。关键字眼：无需排队。
- 优点：吞吐量高，cpu无需唤醒所有的线程，开销低。

- 缺点：会产生线程饥饿现象，可能后到的线程先获取到锁，而前面的线程永远都获取不到

5、读写锁ReadWriteLock

ReadWriteLock是一个读写锁接口。什么是读写锁呢？看下官方文档说明：

ReadWriteLock分为一个读锁和一个写锁。读锁可以被多个线程持有，而写锁只能被一个线程持有。典型的实现类有ReentrantReadWriteLock。

读锁：就是我们常说的共享锁。

写锁：就是常说的独占锁。

示例代码：

public class ReadWriteLock {

    public static void main(String[] args) {
        MyMap map = new MyMap();

        // 写操作
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> map.put(String.valueOf(finalI), String.valueOf(finalI))).start();
        }

        // 读操作
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> map.get(String.valueOf(finalI))).start();
        }
    }

}

// 模拟公共资源类
class MyMap extends HashMap<String, String> {

    @Override
    public String get(Object key) {
        System.out.println(Thread.currentThread().getName() + "获取key:" + key);
        return super.get(key);
    }

    @Override
    public String put(String key, String value) {
        System.out.println(Thread.currentThread().getName() + "写入key:" + key);
        String put = super.put(key, value);
        System.out.println(Thread.currentThread().getName() + "写入key:" + key + "完成");
        return put;
    }
}

如果不加入任何的锁限制，我们直到结果肯定是很随机的。在写入操作时会被其他读线程插队。

加入读写锁后：

public class ReadWriteLock {

    public static void main(String[] args) {
        MyMap map = new MyMap();

        // 写操作
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> map.put(String.valueOf(finalI), String.valueOf(finalI))).start();
        }

        // 读操作
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> map.get(String.valueOf(finalI))).start();
        }
    }

}

// 模拟公共资源类
class MyMap extends HashMap<String, String> {

    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    @Override
    public String get(Object key) {
        try{
            rwLock.readLock().lock();

            System.out.println(Thread.currentThread().getName() + "获取key:" + key);
            return super.get(key);

        } finally {
            rwLock.readLock().unlock();
        }
    }

    @Override
    public String put(String key, String value) {
        try {
            rwLock.writeLock().lock();

            System.out.println(Thread.currentThread().getName() + "写入key:" + key);
            String put = super.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入key:" + key + "完成");
            return put;
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}