ReadWriteLock读写锁

首先对于一个技术，存在就是为了解决某些技术难点。

为什么已经有ReentLock锁，却还要引入读写锁呢？

答案就是为了解决在 读多写少的场景下的性能问题，运用读写锁，能提高在这一场景下的性能优于互斥锁。

首先，什么是读写锁？在Java中读写锁又是怎么实现的？

允许多个线程同时读共享变量，而读写锁的写操作是互斥的，当一个线程在写共享变量的时候，是不允许其他线程执行写操作和读操作。

同时，读写锁又带有3种原则：

1.允许多个线程同时读共享变量。

2.只允许一个线程写共享变量。

3.如果一个写线程正在执行写操作，此时，禁止读线程读共享变量。注意：这里锁降级时，写锁不释放的时候，去获取读锁，还是同一个线程在执行，只是同一个线程去获取写锁和读锁。

在Java中读写锁的实现就是 

final ReadWriteLock rwl = new ReentrantReadWriteLock();

通过rwl能获取读锁和写锁。

同时，使用读写锁一定要注意的几个事项：

1.防止锁的升级，就是在获取读锁却还未释放的时候，不能去获取写锁，这样会陷入阻塞。

2.锁的降级，即指在已经获取写锁的情况下，可以去获取读锁。再释放写锁最后释放读锁。目的是:为了保证数据的可见性，如果先释放写锁，再分段获取读锁，可能再释放写锁后，又有T线程修改了数据，导致再读读到脏数据，而通过锁降级策略，就能保证，再获取读锁时，能保证数据的正确性和可见性，唯一性。 这一定是一种happen-before规则的体现。

 

代码：demo

package com.hnist.lzn.thread;

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Cache<K,V> {

        final Map<K,V> m = new HashMap<>();

        final ReadWriteLock rwl = new ReentrantReadWriteLock();

        final Lock r =  rwl.readLock();

        final Lock w = rwl.writeLock();

        V get(K key){

            r.lock();
            try{

                return m.get(key);
            }finally {
                r.unlock();
            }
        }

        V put(K key, V data){

            w.lock();

            try{

               m.put(key,data);

               return data;
            }finally {
                w.unlock();
            }

        }

    public static void main(String[] args) throws InterruptedException {

            Cache<Character,String> cake = new Cache<>();

            Runnable runnable  = new Runnable() {
                @Override
                public void run() {

                    for(int i = 0;i<26;i++){
                        char chars = (char) ('a'+i);
                        int nums = new Random().nextInt(100);
                        System.out.println("xieru:"+chars+nums+"");
                        cake.put(chars,chars+nums+"");

                    }

                }
            };
            Runnable runnable1 = new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i<26;i++){
                        char chars = (char)('a'+i);
                        System.out.println("du:"+cake.get(chars));
                    }
                }
            };

            Thread th1 = new Thread(runnable);
            Thread th2 = new Thread(runnable1);

            th1.start();
            th1.join();
            th2.start();
    }


}