第十六讲 读写锁

第十六讲 读写锁

1 ReentrantLock 与synchronized 区别

ReentrantLock：
	是一个类，可设置。
	构造方法，默认的构造是非公平锁(false)，也可以设置为公平锁。
	可以手动释放锁。finally中释放锁，不管怎样，最终这把锁都会被释放。
	可以设置超时时间。如果，A线程持有锁，B线程可以等待一定的时间之后，
	如果得不到锁，就放弃。
	看代码执行完了，就会释放锁。
	
synchronized：
	是一个关键字。非公平锁。不可以改变。
	一旦加上锁，是不可以中断的。这个锁有些重。
	A线程一旦持有锁，那么B线程尝试获得锁，
	拿不到的时候就会进入EntryList中等待(死等)。
	这里是看锁标志位改了没有，没改回来就认为是锁住的。
	谁都不要想进去。

可重入：比如说，宿舍中的厕所，第一次A同学上厕所，拿到了这把锁
他在门上贴上自己的名字。下次来的时候，如果这个门上还是贴着A的名字
A直接进入。这叫做可重入。
如果，这个时候，A贴上了自己的名字，他上完厕所，走了。这时候B同学来上厕所。
B也把自己的名字贴上去了。B的名字覆盖了A的名字。过了一段时间A来了，
看到厕所门上不是自己的名字，这时候，他想直接进去是不可以的。A同学要尝试
去修改门上的名字，一旦修改成功，就可以再次进入。

宿舍的厕所门不加锁。但是我们定了一个规则，厕所门上有谁的名字，就是谁在上厕所。
一直修改这个名字，A一直敲门，敲了三分钟(试图修改名字)，里面的人都不出来，换个地方。

synchronized不释放锁，而外面要上厕所的进入entrylist等待。太重了，太不人道了。

2 ReadWriteLock 读写锁

Read：读，只是查看。读书，看书中的内容。
Write：写，修改。写作业，往空白纸上写东西。
比如：Map map = new HashMap();
map中哪个操作是读？哪个操作是写？读：读map中的内容。写：往map中存入数据。
读操作：get(key),写操作：put(key,value)
数据库事务的操作：ACID 原子性、一致性、隔离性、持久性

读锁：没有写操作的时候，是可以被多个线程同时持有的。只读的操作是线程共享的。
写锁：是排他的。也就是一次只能一个线程进行写操作。这个线程操作的时候一定要加锁。
	加了锁才能保证写操作的原子性（要么一次性成功，要么一次性失败）。
读读：共享，如果都是只读，加不加锁无所谓
读写、写写：不共享。一旦写参与了，就一定要加锁。
读写：有读又有写也要加锁。为什么？因为会产生读未提交、读已提交。脏读、幻读。
int i = 10；
A线程修改 i = 100
此时B线程进来读：i = 100
然后A回滚，回到原来的状态(修改失败)，i = 10
B得到的数据是100，这叫做脏读。

比如：A存钱，0 存10000
A修改了账户余额，但是还没有提交，这个操作还没有彻底的完成
B来读，读到10000
A按了取消键。账户真实的余额是：0
B读到的不是账户真实的余额

读已提交：幻读
B读线程，读的时候 10000 没加锁
A写线程，把这10000改成了0
B看到的又是0

线程在有写操作的时候，要保证原子性。
同时涉及到读写操作的时候，就要确保操作的原子性。

3 读写锁的实现

ReadWriteLock:这是一个接口 Interface
它的实现类：ReentrantReadWriteLock 可重入读写锁

public class ReadWriteLockTest {

    private Map<String, String> map = new HashMap<>();
    public void put(String key, String value) {
        System.out.println(Thread.currentThread().getName() + " 开始存入数据");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() + " 存入成功,存入数据为： " + value);
    }

    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + " 开始读取数据");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String value = map.get(key);
        System.out.println(Thread.currentThread().getName() + " 读取数据成功，读取结果为： " + value);
    }
}


public class Client {
    public static void main(String[] args) {
        ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest();
        new Thread(()->{
            readWriteLockTest.put("a","aaa");
        },"A").start();

        new Thread(()->{
            readWriteLockTest.get("a");
        },"B").start();
    }
}
// 某一次运行结果
A 开始存入数据
B 开始读取数据
B 读取数据成功，读取结果为： null
A 存入成功,存入数据为： aaa
    
// 其他的运行结果1：
A 开始存入数据
B 开始读取数据
A 存入成功,存入数据为： aaa
B 读取数据成功，读取结果为： null

// 其他的运行结果2：
A 开始存入数据
B 开始读取数据
B 读取数据成功，读取结果为： aaa
A 存入成功,存入数据为： aaa

以上代码数据不一致。读写有安全问题。

解决方案：
    可以加synchronized，也可以加ReentrantLock
    如果是synchronized，粒度大，锁重
    加ReentrantLock，粒度大，锁的范围和功能比较大。
    在该示例中，我们可以使用读写锁
    读写锁的粒度比ReentrantLock要更小一些。效率要高一些。

public class ReadWriteLockTest {

    private Map<String, String> map = new HashMap<>();
    private ReadWriteLock lock = new ReentrantReadWriteLock();
    public void put(String key, String value) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 开始存入数据");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + " 存入成功,存入数据为： " + value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public void get(String key) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 开始读取数据");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String value = map.get(key);
            System.out.println(Thread.currentThread().getName() + " 读取数据成功，读取结果为： " + value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }

    }
}


public class Client {
    public static void main(String[] args) {
        ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest();
        new Thread(()->{
            for (int i = 0; i < 10; i++)
                readWriteLockTest.put(String.valueOf(i),String.valueOf(i+1));
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++)
             readWriteLockTest.get(String.valueOf(i));
        },"B").start();
    }
}