JUC-how to use ReadWriteLock

as we know.JUC play a important role in in concurrent progammering,the demand for read more to write less.we should use ReadWriteLock,instead of Lock.

first and foremost.let we analyze the requirement of  read more to write less.

operation1	operation2	result
read	read	coexist
read	write	mutex
write	write	mutex

secondly,choose appropriate lock to implement requirement.

package JavaAdvanced;

import com.sun.corba.se.spi.ior.ObjectKey;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author 韦海涛
 * @version 1.0
 * @date 4/2/2021 1:44 PM
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该同时进行。
 * 但是有一个线程想去写共享资源来，就不应该再有其他线程进行读或者写
 * 小总结：
 *  读-读-共存
 *  读-写-不共存
 *  写-写-不共存
 *
 *  写操作：原子+独占:整个过程必须是一个完整的统一体，中间不允许被打断
 *
 *
 */

class MyCache{
    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(String key,Object value){
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t正在写入");
            TimeUnit.SECONDS.sleep(3);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"\t写入完成");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.writeLock().unlock();
        }

    }

    public void get(String key){
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t正在读取");
            TimeUnit.SECONDS.sleep(3);
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName()+"\t读取完成"+result);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.readLock().unlock();
        }
    }
}

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

        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                myCache.get(tempInt+"");
            },String.valueOf(i)).start();
        }
    }
}

refer to the above code,we can konw,if write locked.the next write lock cannot achieve,and read lock also cannot achieve until current wirte unlocked.