独占锁 / 共享锁、读写锁

独占锁和共享锁

独占锁: 指该锁一次只能被一个线程所持有。对ReentrantLockSynchronized而言都是独占锁。
共享锁: 指該锁可被多个线程所持有。

读写锁

ReadWriteLock是一个读写锁接口，ReentrantReadWriteLock类（可重入读写锁）是读写锁ReadWriteLock的一个实现类；ReentrantReadWriteLock可重入读写锁有两种模式，其写模式writeLock()）是一个独占锁，其读模式
（readLock()）是一个共享锁。ReentrantReadWriteLock保证了可并发读的高效性。

为了提高并发效率，我们希望在多线程并发读写时满足一下规则：

读—读 ：能共存。
读—写 ：互斥关系，不能共存。
写—写 ：互斥关系，不能共存。

而这些规则ReentrantReadWriteLock已经帮我们实现。

案例如下

class MyCache {
    //缓存更新快，需要用volatile修饰
    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {
        rwLock.writeLock().lock();//写模式
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "正在写入： " + key);
            //模拟网络传输
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (Exception e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t" + "写入完成");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            rwLock.writeLock().unlock();
        }
    }

    public void get(String key) {
        rwLock.readLock().lock();//读模式
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "正在读取： " + key);
            //模拟网络传输
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (Exception e) {
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t" + "读取完成： " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            rwLock.readLock().unlock();
        }
    }
}

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache cache = new MyCache();
        //写
        for (int i = 1; i <= 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                cache.put(tempInt + "", tempInt + "");
            }, String.valueOf(i)).start();
        }
        //读
        for (int i = 1; i <= 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                cache.get(tempInt + "");
            }, String.valueOf(i)).start();
        }
    }
}

运行结果如下：

程序中有5个线程写入数据，5个线程读数据；当一个线程正在写的时候，其他读写线程都必须阻塞等待，在其写入完成之后其他线程才能获取锁。可见写-写，写-读都是互斥的。
当线程开始读数据时，该线程还未读取完成时，其他四个线程也已经获取读锁读数据了。可见读-读是共享的。