1. 就是共享锁和排他锁（读锁和写锁）
    2. 有的是读线程，有的是写线程
    3. 简单上锁时，效率特别低
    4. 上的是读锁的时候，其他线程可以读，但是不可以写；上的是写锁的时候，其他线程不可以读也不可以写
    5. 这里的锁与数据库里的不会冲突，是两回事；数据库的锁是数据库中的锁，从数据库中读出来到程序中，程序是在内存中的；到内存中了之后，数据库就已经读完了
    6. 不会出现得不到锁，除非cpu只挑读或者写的运行
    7. 与ReentrantLock的Condition很类似
    8. 互斥锁=排他锁
    9. 读的时候不加锁会出现读的时候可以往里面写，会造成数据不一致（脏读）
    1. package com.mashibing.juc.c_020;
    3. import java.util.Random;
    4. import java.util.concurrent.atomic.LongAdder;
    5. import java.util.concurrent.locks.Lock;
    6. import java.util.concurrent.locks.ReadWriteLock;
    7. import java.util.concurrent.locks.ReentrantLock;
    8. import java.util.concurrent.locks.ReentrantReadWriteLock;
    10. public class T10_TestReadWriteLock {
    11.     static Lock lock = new ReentrantLock();
    12.     private static int value;
    14.     static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    15.     static Lock readLock = readWriteLock.readLock();
    16.     static Lock writeLock = readWriteLock.writeLock();
    18.     public static void read(Lock lock) {
    19.         try {
    20.             lock.lock();
    21.             Thread.sleep(1000);
    22.             System.out.println("read over!");
    23.             //模拟读取操作
    24.         } catch (InterruptedException e) {
    25.             e.printStackTrace();
    26.         } finally {
    27.             lock.unlock();
    28.         }
    29.     }
    31.     public static void write(Lock lock, int v) {
    32.         try {
    33.             lock.lock();
    34.             Thread.sleep(1000);
    35.             value = v;
    36.             System.out.println("write over!");
    37.             //模拟写操作
    38.         } catch (InterruptedException e) {
    39.             e.printStackTrace();
    40.         } finally {
    41.             lock.unlock();
    42.         }
    43.     }
    49.     public static void main(String[] args) {
    50.         //Runnable readR = ()-> read(lock);
    51.         Runnable readR = ()-> read(readLock);
    53.         //Runnable writeR = ()->write(lock, new Random().nextInt());
    54.         Runnable writeR = ()->write(writeLock, new Random().nextInt());
    56.         for(int i=0; i<18; i++) new Thread(readR).start();
    57.         for(int i=0; i<2; i++) new Thread(writeR).start();
    60.     }
    61. }