Day37 尚硅谷JUC——乐观锁、悲观锁、读写锁、锁降级

我是大白 (●—●) ，这是我开始学习记录大白Java软件攻城狮晋升之路的第三十七天，今天学习的是【尚硅谷】大厂必备技术之JUC并发编程

一、概述

1.悲观锁

顾名思义，就是比较悲观的锁，总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现

2. 乐观锁

乐观锁总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

3. 表锁和行锁

在一张数据库表中：

• 表锁会对整张表进行加锁，在此情况下其他线程就无法去获取该表的资源。
• 行锁会对该表的某一行数据进行加锁，其他线程可以访问该表，但是无法获取该行数据进行操作，从而阻塞线程。

4. 读锁和写锁

读锁：是共享锁，会发生死锁。若事务T对数据对象A加上读锁，则事务T可以读A但不能修改A，其他事务只能再对A加读锁，而不能加写锁，直到T释放A上的读锁。这保证了其他事务可以读A，但在T释放A上的读锁之前不能对A做任何修改。
读锁发生死锁的情况，主要是因为读锁只能读数据，而要对数据修改时，需要释放锁，而其他线程同时也加了读锁，所以1线程需要等2线程读锁释放才可以修改：

写锁：独占锁，会发生死锁。若事务T对数据对象A加上写锁，事务T可以读A也可以修改A，其他事务不能再对A加任何锁，直到T释放A上的锁。这保证了其他事务在T释放A上的锁之前不能再读取和修改A。

写锁的死锁情况，1线程对第一个资源进行写操作，2线程对第二个资源进行写操作，同时1线程写完需要去修改第二个资源，2线程又要对第一个资源进行修改，都发现资源被另一个线程锁住，因此无法释放写锁，导致互相等待释放锁而导致死锁。

二、案例实现

利用读写锁ReentrantReadWriteLock模拟一个缓存。

/**
 * @author Administrator
 * 多个线程同时读一个资源类没有问题，所以为了满足并发量，读取共享资源应该可以同时进行。
 * 但是  如果有一个线程想去写共享资源，就不应该再有其它线程可以对该资源进行读或写
 * <p>
 * 总结：
 * 读 - 读能共存
 * 读 - 写不能共存
 * 写 - 写不能共存
 * <p>
 * 写操作： 原子+独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt + "", tempInt + "");
            }, String.valueOf(i)).start();
        }

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

/**
 * 资源类
 */
class MyCache {
    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    public void put(String key, Object value) {

        rwLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在写入: " + key);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rwLock.writeLock().unlock();
        }

    }

    public void get(String key) {
        rwLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在读取");
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rwLock.readLock().unlock();
        }
    }
}

结果如下

会发现在写操作的时候，是一个线程写完其它线程才能写，而读线程可以同时读取。
不加锁就会导致还没有写完数据，就去获取数据的情况

三、读写锁的演变

读写锁：一个资源可以被多个读线程访问，或者可以被一个写线程访问，但是不能同时存在读写线程，读写互斥，读读共享的

读写锁的演变阶段：

1. 第一：无锁，即多线程不加锁抢夺资源，会造成许多原子性、可见性、有序性的问题。
2. 第二：添加独占锁synchronized和ReentrantLock，每次都会独占资源或者方法，只能由一个线程进行操作，性能上较低。
3. 第三：读写锁，ReentrantReadWriteLock。读锁和读锁可以共享，同时多个线程进行读操作，提升了性能，但是缺点是写锁只能独享，不能与其他写操作或者读操作共享资源，另外会造成锁饥饿的问题，一直读没有写操作。

四、读写锁的降级

锁降级：将写入锁降级为读锁。写线程获取写入锁后可以获取读取锁, 然后释放写入锁, 这样就从写入锁变成了读取锁, 从而实现锁降级的特征

public class ReadWriteLockReduce {
    public static void main(String[] args) {
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
        ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();

        //锁降级
        //1.获取写锁
        writeLock.lock();
        System.out.println("write");
        //2.获取读锁
        readLock.lock();
        System.out.println("read");
        //3.释放写锁
        writeLock.unlock();
        //4.释放读锁
        readLock.unlock();
    }
}

锁降级以后, 写锁并不会直接降成读锁, 不会随着读锁的释放而释放, 因此需要显式地释放写锁，结果如图所示

但是读锁不能升级为写锁

public class ReadWriteLockReduce {
    public static void main(String[] args) {
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
        ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();

        //锁降级
        //2.获取读锁
        readLock.lock();
        System.out.println("read");
        //1.获取写锁
        writeLock.lock();
        System.out.println("write");

        //3.释放写锁
        writeLock.unlock();
        //4.释放读锁
        readLock.unlock();
    }
}

结果如图所示，可以看到没有获取到写锁并执行输出操作