ReadWriteLock de alta concurrencia (JUC) de JAVA (bloqueo de lectura y escritura)

Esta vez explicaré ReadWriteLock (bloqueo de lectura-escritura) de JUC:
no hay ningún problema con varios subprocesos que leen una clase de recursos al mismo tiempo, por lo que para cumplir con la cantidad de simultaneidad, la lectura de recursos compartidos debería ser posible al mismo tiempo. Sin embargo, si un subproceso desea compartir la clase de recurso, no debería haber otros subprocesos que puedan leer o escribir en el recurso.

• Resumen: leer y leer coexisten, leer y escribir no coexistir, escribir y escribir no coexistir
  A continuación, veamos un caso: el
  código es el siguiente:

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

        for (int i = 0; i < 5; i++) {
            final int finali= i;
            new Thread(() -> {
                try {
                    myCache.get(finali+"");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }
}

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

    public void put(String key, Object value) throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "\t-----写入数据key");
        Thread.sleep(3000);
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "\t-----写入数据成功");
    }

    public void get(String key) throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + "\t读取数据key");
        Thread.sleep(3000);
        Object result = map.get(key);
        System.out.println(Thread.currentThread().getName() + "\t读取数据成功" + result);
    }
}

Los resultados de la operación son los siguientes:

Lo que podemos ver es que cuando se escriben datos en 1, no se ha escrito correctamente en este momento, y la operación de lectura se ha realizado en 1, al igual que la atomicidad de nuestra base de datos, no hay Una vez que se escriben los datos, se realiza la operación de lectura, por lo que la lectura está vacía.
A continuación, echemos un vistazo al efecto de agregar un bloqueo de lectura-escritura: el
código es el siguiente:
aquí solo necesita modificar MyCache:

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

    public void put(String key, Object value) throws InterruptedException {
        readWriteLock.writeLock().lock();  //上写锁
        try {
            System.out.println(Thread.currentThread().getName() + "\t-----写入数据key");
            Thread.sleep(3000);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t-----写入数据成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
    public void get(String key) throws InterruptedException {
        readWriteLock.readLock().lock();  //上读锁
        try {
            System.out.println(Thread.currentThread().getName() + "\t读取数据key");
            Thread.sleep(3000);
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t读取数据成功" + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

Los resultados de la operación son los siguientes:

podemos ver que hemos mantenido la consistencia en la escritura, garantías de lectura simultáneas y evitado operaciones de lectura durante la escritura, por lo que esta es la función del bloqueo de lectura-escritura.

Resumen: Leer y leer conviven, leer y escribir no conviven, escribir y escribir no conviven