更新时间:2022-09-21 20:51:07
不管是内部锁还是Lock都是独占锁,或者称之排他锁,即读写互斥、写写互斥、读读互斥;与排他锁相对的另一种锁是共享锁,Java的ReadWriteLock是一种共享锁,提供读读共享,但读写和写写仍然互斥。
ReadWriteLock最大的特性就是读读共享,比如A线程读锁正在进行读取操作,此时如果B线程请求读锁,那么B线程可以马上顺利获得读锁而无需等待,但此时如果C线程请求写锁,那么C线程需要等待锁可用。ReadWriteLock由于提供了读读共享而增加了复杂性,所以在读写都相当频繁的场景并不能体现出性能优势,只有在读操作极多而写操作极少的场景下才能体现其性能优势。比如,一个应用系统安装完成后需要导入一批维护性的初始化数据,这些数据可以通过界面修改,但需要修改的情况极少,当系统一启动就会自动加载初始化数据到指定数据结构(如HashMap)供各个模块读取使用,那么可以为这些数据的读写加ReadWriteLock,以提高读取性能并保持数据的一致性。
ReentrantReadWriteLock类是ReadWriteLock接口的一个实现,它与ReentrantLock类一样提供了公平竞争与不公平竞争两种机制,默认也是使用非公平竞争机制。ReentrantLock是排他锁,使用非公平竞争机制时,抢占的机会相对还是比较少的,只有当新请求恰逢锁释放时才有机会抢占,所以发生线程饥饿的现象几乎很少。然而ReentrantReadWriteLock是共享锁,或者说读读共享,并且经常使用于读多写少的场景,即请求读操作的线程多而频繁而请求写操作的线程极少且间隔长,在这种场景下,使用非公平竞争机制极有可能造成写线程饥饿。比如,R1线程此时持有读锁且在进行读取操作,W1线程请求写锁所以需要排队等候,在R1释放锁之前,如果R2,R3,...,Rn 不断的到来请求读锁,因为读读共享,所以他们不用等待马上可以获得锁,如此下去W1永远无法获得写锁,一直处于饥饿状态。所以使用ReentrantReadWriteLock类时,小心选择公平机制,以免遇到出乎预料的结果。
最后,Java5的读写锁实现有瑕疵,可能发生死锁,在Java6已经修复,所以避免使用Java5读写锁。
示例代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
9
|
import java.util.HashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class TestReadWriteLock {
private static final int MAX_INDEX = 100 ;
private HashMap<Integer,Integer> mInitDataMap;
private ReadWriteLock mRWlock;
private volatile boolean isNonStop;
public void start() {
this .isNonStop = true ;
}
public void stop() {
this .isNonStop = false ;
}
public TestReadWriteLock(){
init();
}
private void init() {
mInitDataMap = new HashMap<Integer,Integer>(MAX_INDEX);
mRWlock = new ReentrantReadWriteLock();
for ( int i= 0 ; i<MAX_INDEX; i++){
mInitDataMap.put(i, i);
}
}
private class Reader implements Runnable{
@Override
public void run() {
while (isNonStop){
mRWlock.readLock().lock();
System.out.println(Thread.currentThread().getName() + ": get the read lock." );
try {
mInitDataMap.get(( int )((MAX_INDEX- 1 )*Math.random()));
//此处增加读取时间使写线程更容易处于饥饿状态
/*try {
TimeUnit.MILLISECONDS.sleep((long) (1000*Math.random()));
} catch (InterruptedException e) {
e.printStackTrace();
}*/
}
finally{
mRWlock.readLock().unlock();
}
}
}
}
private class Writer implements Runnable{
@Override
public void run() {
while(isNonStop){
mRWlock.writeLock().lock();
System.out.println(Thread.currentThread().getName() + ": get the write lock.");
try{
mInitDataMap.put((int)((MAX_INDEX-1)*Math.random()), (int)((MAX_INDEX-1)*Math.random()));
//此处增加读取时间使写线程更容易处于饥饿状态
/*try {
TimeUnit.MILLISECONDS.sleep((long) (1000));
} catch (InterruptedException e) {
e.printStackTrace();
}*/
}
finally {
mRWlock.writeLock().unlock();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
TestReadWriteLock testReadWriteLock = new TestReadWriteLock();
testReadWriteLock.start();
for ( int i= 0 ; i< 5 *MAX_INDEX; i++){
new Thread(testReadWriteLock. new Reader()).start();
}
new Thread(testReadWriteLock. new Writer()).start();
TimeUnit.SECONDS.sleep( 5 );
testReadWriteLock.stop();
}
}
|