Java多线程之Lock的使用

Java多线程之Lock的使用

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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
* Lockers
* 在多线程编程里面一个重要的概念是锁定,如果一个资源是多个线程共享的,为了保证数据的完整性,
* 在进行事务性操作时需要将共享资源锁定,这样可以保证在做事务性操作时只有一个线程能对资源进行操作,
* 从而保证数据的完整性。在5.0以前,锁定的功能是由Synchronized关键字来实现的。
*/
public class Lockers {

/**
* 测试Lock的使用。在方法中使用Lock,可以避免使用Synchronized关键字。
*/
public static class LockTest {

Lock lock = new ReentrantLock();// 锁
double value = 0d; // 值
int addtimes = 0;

/**
* 增加value的值,该方法的操作分为2步,而且相互依赖,必须实现在一个事务中
* 所以该方法必须同步,以前的做法是在方法声明中使用Synchronized关键字。
*/
public void addValue(double v) {
lock.lock();// 取得锁
System.out.println("LockTest to addValue: " + v + " "
+ System.currentTimeMillis());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
this.value += v;
this.addtimes++;
lock.unlock();// 释放锁
}

public double getValue() {
return this.value;
}
}
public static void testLockTest() throws Exception{
final LockTest lockTest = new LockTest();
// 新建任务1,调用lockTest的addValue方法
Runnable task1 = new Runnable(){
public void run(){
lockTest.addValue(55.55);
}
};
// 新建任务2,调用lockTest的getValue方法
Runnable task2 = new Runnable(){
public void run(){
System.out.println("value: " + lockTest.getValue());
}
};
// 新建任务执行服务
ExecutorService cachedService = Executors.newCachedThreadPool();
Future future = null;
// 同时执行任务1三次,由于addValue方法使用了锁机制,所以,实质上会顺序执行
for (int i=0; i<3; i++){
future = cachedService.submit(task1);
}
// 等待最后一个任务1被执行完
future.get();
// 再执行任务2,输出结果
future = cachedService.submit(task2);
// 等待任务2执行完后,关闭任务执行服务
future.get();
cachedService.shutdownNow();
}

/**
* ReadWriteLock内置两个Lock,一个是读的Lock,一个是写的Lock。
* 多个线程可同时得到读的Lock,但只有一个线程能得到写的Lock,
* 而且写的Lock被锁定后,任何线程都不能得到Lock。ReadWriteLock提供的方法有:
* readLock(): 返回一个读的lock
* writeLock(): 返回一个写的lock, 此lock是排他的。
* ReadWriteLockTest很适合处理类似文件的读写操作。
* 读的时候可以同时读,但不能写;写的时候既不能同时写也不能读。
*/
public static class ReadWriteLockTest{
// 锁
ReadWriteLock lock = new ReentrantReadWriteLock();
// 值
double value = 0d;
int addtimes = 0;

/**
* 增加value的值,不允许多个线程同时进入该方法
*/
public void addValue(double v) {
// 得到writeLock并锁定
Lock writeLock = lock.writeLock();
writeLock.lock();
System.out.println("ReadWriteLockTest to addValue: " + v + " "
+ System.currentTimeMillis());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
try {
// 做写的工作
this.value += v;
this.addtimes++;
} finally {
// 释放writeLock锁
writeLock.unlock();
}
}
/**
* 获得信息。当有线程在调用addValue方法时,getInfo得到的信息可能是不正确的。
* 所以,也必须保证该方法在被调用时,没有方法在调用addValue方法。
*/
public String getInfo() {
// 得到readLock并锁定
Lock readLock = lock.readLock();
readLock.lock();
System.out.println("ReadWriteLockTest to getInfo "
+ System.currentTimeMillis());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
try {
// 做读的工作
return this.value + " : " + this.addtimes;
} finally {
// 释放readLock
readLock.unlock();
}
}
}

public static void testReadWriteLockTest() throws Exception{
final ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest();
// 新建任务1,调用lockTest的addValue方法
Runnable task_1 = new Runnable(){
public void run(){
readWriteLockTest.addValue(55.55);
}
};
// 新建任务2,调用lockTest的getValue方法
Runnable task_2 = new Runnable(){
public void run(){
System.out.println("info: " + readWriteLockTest.getInfo());
}
};
// 新建任务执行服务
ExecutorService cachedService_1 = Executors.newCachedThreadPool();
Future future_1 = null;
// 同时执行5个任务,其中前2个任务是task_1,后两个任务是task_2
for (int i=0; i<2; i++){
future_1 = cachedService_1.submit(task_1);
}
for (int i=0; i<2; i++){
future_1 = cachedService_1.submit(task_2);
}
// 最后一个任务是task_1
future_1 = cachedService_1.submit(task_1);
// 这5个任务的执行顺序应该是:
// 第一个task_1先执行,第二个task_1再执行;这是因为不能同时写,所以必须等。
// 然后2个task_2同时执行;这是因为在写的时候,就不能读,所以都等待写结束,
// 又因为可以同时读,所以它们同时执行
// 最后一个task_1再执行。这是因为在读的时候,也不能写,所以必须等待读结束后,才能写。

// 等待最后一个task_2被执行完
future_1.get();
cachedService_1.shutdownNow();
}

public static void main(String[] args) throws Exception{
Lockers.testLockTest();
System.out.println("---------------------");
Lockers.testReadWriteLockTest();
}
}

原文链接

-------------已经触及底线 感谢您的阅读-------------

本文标题:Java多线程之Lock的使用

文章作者:趙小傑~~

发布时间:2018年01月18日 - 00:00:00

最后更新:2019年09月16日 - 19:34:10

原始链接:https://cnsyear.com/posts/e94ca8d2.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

0%