ReentrantLock介绍使用

思路就是，在大并发下对数据进行修改，读和写同时到来。
比如某国人都人爱看书，一批《金*梅》被广大男女借阅查看，
排队扫码借阅。供不应求，这时A看完了去还书，B去借阅，
系统承受波动，巧的是C也来借。
系统A已经把书换了，书已经和B的设备绑定了，but  C来看哎呦我靠还有一本没人借，此时去扫码发现已经被B借走了，，以为没人借其实已经被借走，出现了幻读，这不读写锁就派上用场了


那有人就说了数据库不是有读写操作吗，那不是为了给数据库减轻压力吗，再说了mysal还有锁的间隙，像某宝5Min  15w请求，数据库也得歇逼啊

package com.example.demo.config; import java.util.Arrays; 
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWriteLock; 
import java.util.concurrent.locks.ReentrantLock; 
import java.util.concurrent.locks.ReentrantReadWriteLock; 
public class ReadWreteLock0 { 
//锁 
private final Lock lock = new ReentrantLock(); 
//读写锁
 private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
 //读锁 
private final Lock read = readWriteLock.readLock(); 
//写锁 
private final Lock write = readWriteLock.writeLock(); 
private int constant[] = new int[10]; //缺点：把读和写操作都锁上了，去读取你也锁，写也你锁
     //合理的逻辑应该是，写的时候加锁，读的时候不需要加锁
    public void decr(Integer index) {
        long l = 0;
        long l1;
        lock.lock();
        try {
            l = System.currentTimeMillis() / 1000;
            constant[index] += 1;
        } finally {
            lock.unlock();
            l1 = System.currentTimeMillis() / 1000;
            long l2 = l1 - l;
            System.out.println(l2);
        }
    }

    public int[] get() {
        lock.lock();
        try {
            return Arrays.copyOf(constant, constant.length);
        } finally {
            lock.unlock();
        }
    }



    //写的时候不可以读也不可以写
    public void decrNotReadAndWrite(Integer index) {
        long l = 0;
        long l1;
        write.lock();
        try {
            l = System.currentTimeMillis() / 1000;
            constant[index] += 1;
        } finally {
            write.unlock();
            l1 = System.currentTimeMillis() / 1000;
            long l2 = l1 - l;
            System.out.println(l2);
        }
    }
    //读的时候可以读，但是不可以写  （小声比比，这个是悲观锁，后面有解决方案进一步提升并发性能）
    public int[] getRead() {
        read.lock();
        try {
            return Arrays.copyOf(constant, constant.length);
        } finally {
            read.unlock();
        }
    }
    public static void main(String[] args) {
//        for (int i = 0; i < 10; i++) {
//            ReadWreteLock0 readWreteLock0 = new ReadWreteLock0();
//            readWreteLock0.decr(i);
//        }

       ReadWreteLock0 readWreteLock0 = new ReadWreteLock0();

        readWreteLock0.decrNotReadAndWrite(2);

    }
}