Java读写锁理论和代码验证
1、Java读写锁理论
写锁（独占锁）：是指该锁一次只能被一个线程锁持有。对ReentrantLock和Sychronized而言都是独占锁。
读锁（共享锁）：是指该锁可被多个线程持有。对ReentrantReadWriteLock而言，其读锁是共享锁，其写锁是独占锁。读锁的共享性可保证并发读是非常高效的，读写、写读、写写的过程都是互斥的。
2、Java读写锁代码验证
Demo One：代码没有加读写锁的情况
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 多个线程同时读一个资源类的时候是没有任何问题，所以为了满足并发量，读取共享资源应该同时进行。
* 但是，如果有一个线程想去写共享资源，就不应该有其他线程去读或者写
* <p>
* 总结：
* 读-读共存
* 读-写不共存
* 写-读不共存
* 写-写不共存
*
* 写操作：原子+独占，整个过程必须是一个完整体，中间不能有任何中断
*/
public class ReentrantReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache = new MyCache();
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> {
myCache.put(finalI + "", finalI + "");
}, i + "").start();
}
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> {
myCache.get(finalI + "");
}, i + "").start();
}
}
}
class MyCache {
private volatile Map<String, String> map = new HashMap<>();
//private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
public void put(String key, String value) {
System.out.println(Thread.currentThread().getName() + "正在写......");
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
map.put(key, value);
System.out.println(Thread.currentThread().getName() + "写已经完成");
}
public String get(String key) {
System.out.println(Thread.currentThread().getName() + "正在读......");
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
String value = map.get(key);
System.out.println(Thread.currentThread().getName() + "读已经完成");
return value;
}
}
程序执行结果如下：0号线程还没有写完就4号线程写操作、3号线程写操作、2号线程写操作等等打断，所以没有加读写锁的并发操作并不安全。
Demo Two：代码加了读写锁的情况下
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 多个线程同时读一个资源类的时候是没有任何问题，所以为了满足并发量，读取共享资源应该同时进行。
* 但是，如果有一个线程想去写共享资源，就不应该有其他线程去读或者写
* <p>
* 总结：
* 读-读共存
* 读-写不共存
* 写-读不共存
* 写-写不共存
*
* 写操作：原子+独占，整个过程必须是一个完整体，中间不能有任何中断
*/
public class ReentrantReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache = new MyCache();
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> {
myCache.put(finalI + "", finalI + "");
}, i + "").start();
}
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> {
myCache.get(finalI + "");
}, i + "").start();
}
}
}
class MyCache {
private volatile Map<String, String> map = new HashMap<>();
private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
public void put(String key, String value) {
rwLock.writeLock().lock();
System.out.println(Thread.currentThread().getName() + "正在写......");
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
map.put(key, value);
System.out.println(Thread.currentThread().getName() + "写已经完成");
rwLock.writeLock().unlock();
}
public String get(String key) {
rwLock.readLock().lock();
System.out.println(Thread.currentThread().getName() + "正在读......");
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
String value = map.get(key);
System.out.println(Thread.currentThread().getName() + "读已经完成");
rwLock.readLock().unlock();
return value;
}
}
程序执行结果如下：0号线程写操作完全执行完成之后才会去执行1、3、2、4号线程的写操作，读操作就不需要保证原子+独占，可以随机读取共享资源，保证读的并发性能。
