并发编程---------读写锁

什么是读写锁？
读写锁本质上维护了一对锁，一个读锁，一个写锁。通过锁分离从而提高并发性。

jdk1.5之前只能依托synchronized关键字 进行等待/通知机制，来实现该功能。
jdk1.5之后便有了读锁写的支持，Java并发包也提供了读锁写的实现ReentrantReadWriteLock
读锁和写锁的注意点
1.
两者，都是互斥的。 就是当 当前线程 要获取 写锁，而此时该共享资源已经被其他线程的读锁所占有，只能阻塞当前线程。同理，当 当前线程 要获取读锁时，而其他线程的写锁占有该资源，当前线程被迫阻塞。 这样一来，才能保证数据的可见性。
2.
读写锁的获取。对应于ReentrantLock的所获取机制一样只是条件不同罢了。
定义一个整型变量同样来表示，读锁写锁的数量。

写锁获取代码实现：

protected final boolean tryAcquired(int acquires) {
		Thread current = Thread.currentThread();
		int c = getstat();
		int w = exclusiveCount(c);
		if (c != 0) {
			if (w == 0 || current != getExclusiveOwnerThread())
				return false;
			if (w + exclusiveCount(acquires) > MAX_COUNT)
				throw new Error();
			setstat(c + acquires);
		}
		if (writerShouldBlock() || !connpareAndSetState(c, c + acquires))
			return false;

		setExclusiveOwnerThread(current);
		return true;
	}

写锁的释放： 其实和ReetrantLock 一样的，大家也可以看👇

https://blog.csdn.net/m0_51085029/article/details/122104201

读锁获取：

只需要把变量值增加改为（1<<16）; 其他其实都是一样的

int c = getstat();
int nextc = c + (1 << 16);

实现原理：

基于cas操作
不懂cas操作的朋友可以看👇
       https://blog.csdn.net/m0_51085029/article/details/122038913

锁降级

定义： 指的是写锁降级为读锁。

具体流程： 获取写锁 ----> 获取读锁 ----> 释放写锁 ----> 释放读锁。

为什么要锁降级呢？
因为保证数据的可见性，如果没有读锁的话，对于写锁的释放很有可能，有其他线程的写锁再次获取，而这时写进内存的数据没有被感知，就开始另一线程的写操作。
借此，就是保证能及时利用一些刚更新的数据。

代码实现：

  public void processData(){
     readlock.lock();
     //update 用来表示数据是否更新 初值false 没有更新
     if(!update){
            readlock.unlock();
            writelock.lock();
            try{
                  if(!update){
                    //准备数据的流程
                    update=true;
                  }
                  readlock.lock();
            }finally{
               wirtelock.unlock();
            }
     }
     try{
          //使用数据
     } finally{
        readlock.unlock();
     }
  }