JUC学习笔记-07-读写锁的使用

读写锁ReadWriteLock的特性：

• 读写锁的使用场合是：读取数据的频率远大于修改共享数据的频率。可以提高并发性能。
• 读锁允许多个reader线程同时持有，而写锁最多只能有一个线程持有。
• 如果一个线程已经持有了写锁，则可以再持有读或者写锁即可重入。
• 如果一个线程已经持有了读锁，则在释放该读锁之前，不能再持有写锁。
• 如果当前线程是读状态，那么其他线程也同时马上可以获取读锁，但若想获取写锁，就会禁止进入转而进入等待队列，后面想要获取读锁或者写锁的线程也必须进入等待队列。等正在工作的线程释放锁才能获取到。

读写锁与普通锁有什么区别？
普通锁或者添加synchronized关键字的方式也可以实现有如读写锁效果，只需要在写操作的方法上添加synchronized关键字或者添加普通锁，而读操作上不添加，但这与读写锁的功能性差别在哪呢？因为读写锁可以实现更加细粒度的操作，实现细粒度的过程可以参考链接，而普通锁或synchronized的方式比较粗粒度，在我们读数据的时候很可能会读到很多的null值，因为读操作和写操作一个无锁一个有锁不互斥，在写入数据之前可能就读取数据导致读到的是空值。

具体过程参考：轻松掌握java读写锁(ReentrantReadWriteLock)的实现原理

读写锁的实现

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        int num = 100;
        for (int i = 1; i <= num; i++) {
            int finalI = i;
            new Thread(() -> {

                myCache.write(String.valueOf(finalI), String.valueOf(finalI));

            },String.valueOf(i)).start();
        }

        for (int i = 1; i <= num; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.read(String.valueOf(finalI));
            },String.valueOf(i)).start();
        }
    }
}

//读写锁实现类
class MyCacheLock {
    private volatile Map<String, String> map = new HashMap<>();
    ReadWriteLock readWriteLock= new ReentrantReadWriteLock();

    public void write(String key, String value) {
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "线程开始写入");
            map.put(key, value);
            System.out.println(map.get(key));
            System.out.println(Thread.currentThread().getName() + "线程写入ok");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public void read(String key) {
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "线程开始读取");
            System.out.println(map.get(key));
            System.out.println(Thread.currentThread().getName() + "线程写读取ok");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }

    }
}

// 普通锁实现类
class MyCache {
    private volatile Map<String, String> map = new HashMap<>();
    Lock lock= new ReentrantLock();

    public void write(String key, String value) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "线程开始写入");
            map.put(key, value);
            System.out.println(map.get(key));
            System.out.println(Thread.currentThread().getName() + "线程写入ok");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void read(String key) {
        System.out.println(Thread.currentThread().getName() + "线程开始读取");
        System.out.println(map.get(key));
        System.out.println(Thread.currentThread().getName() + "线程写读取ok");
    }
}