Java中常见的锁-----＞读写锁

独占锁

指该锁一次只能被一个线程所持有对于ReentrantLock和synchronized而言都是独占锁

共享锁

指该锁可以被多个线程所持有

对ReentrantReadWriteLock而言其读锁是共享锁，读锁是独占锁

读锁共享锁可保证并发读是非常高效的，其中读写，写读，写写是互斥的

上代码

package com.example.demo;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁,多个线程同时读一个资源类没有任何问题，为了满足并发量，读取，共享
 * 应该同时进行
 * 但是如果有一个线程进行写 *** 作，就不应该由其他的线程来进行读写 *** 作
 * 例如：
 * 写---写 互斥不共存
 * 写---读 互斥不共存
 * 读--读 不互斥共享
 *
 * 写 *** 作：中间必须是一个完整的统一体，中间不允许被打断
 */

class MyCache {
    private volatile Map map = new HashMap<>();
    private ReentrantReadWriteLock readWriteLock =new ReentrantReadWriteLock();

    // 写入数据
    public void put(String key, Object value) {
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"号线程写入数据开始，key="+key);
            map.put(key, value);
            // 模拟程序执行过程，但是不会出现多次连续写
            try {
                TimeUnit.MICROSECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"号线程写入数据结束");
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    // 读出数据
    public void get(String key) {
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"号线程读出数据开始");
            Object o = map.get(key);
            // 模拟程序执行过程，可以出现多次连续读
            try {
                TimeUnit.MICROSECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"号线程读出数据结束，key="+key);
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

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

    }
}

运行结果：

1号线程写入数据开始，key=1
1号线程写入数据结束
2号线程写入数据开始，key=2
2号线程写入数据结束
5号线程写入数据开始，key=5
5号线程写入数据结束
4号线程写入数据开始，key=4
4号线程写入数据结束
3号线程写入数据开始，key=3
3号线程写入数据结束
1号线程读出数据开始
3号线程读出数据开始
4号线程读出数据开始
2号线程读出数据开始
5号线程读出数据开始
4号线程读出数据结束，key=4
5号线程读出数据结束，key=5
3号线程读出数据结束，key=3
1号线程读出数据结束，key=1
2号线程读出数据结束，key=2

小总结

一个线程加上写锁，那其他的线程无论是获取写锁还是获取读锁都只能等待该线程释放写锁，而一个线程加上读锁，那其他的线程获取写锁需要等待，但是多个线程同时获取读锁；
简单来说就是：写的时候其他线程不能写不能读，而读的时候其他线程可以读但不能写