我是大白 (●—●) ,这是我开始学习记录大白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();
}
}
}
结果如下
会发现在写操作的时候,是一个线程写完其它线程才能写,而读线程可以同时读取。
不加锁就会导致还没有写完数据,就去获取数据的情况
三、读写锁的演变
读写锁:一个资源可以被多个读线程访问,或者可以被一个写线程访问,但是不能同时存在读写线程,读写互斥,读读共享的
读写锁的演变阶段:
- 第一:无锁,即多线程不加锁抢夺资源,会造成许多原子性、可见性、有序性的问题。
- 第二:添加独占锁synchronized和ReentrantLock,每次都会独占资源或者方法,只能由一个线程进行操作,性能上较低。
- 第三:读写锁,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();
}
}
结果如图所示,可以看到没有获取到写锁并执行输出操作