1 等待多线程完成的CountDownLatch
CountDownLatch允许一个或多个线程等待其他线程完成操作。
代码示例如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package
com.tlk.chapter8;
import
java.util.concurrent.CountDownLatch;
public
class
CountDownLatchTest {
static
CountDownLatch c =
new
CountDownLatch(
2
);
public
static
void
main(String[] args)
throws
InterruptedException {
new
Thread(
new
Runnable() {
@Override
public
void
run() {
System.out.println(
1
);
c.countDown();
System.out.println(
2
);
c.countDown();
}
}).start();
c.await();
System.out.println(
"3"
);
}
}
|
使用场景:
- 实现最大的并行性:有时我们想同时启动多个线程,实现最大程度的并行性。例如,我们想测试一个单例类。如果我们创建一个初始计数为1的CountDownLatch,并让所有线程都在这个锁上等待,那么我们可以很轻松地完成测试。我们只需调用 一次countDown()方法就可以让所有的等待线程同时恢复执行。
- 开始执行前等待n个线程完成各自任务:例如应用程序启动类要确保在处理用户请求前,所有N个外部系统已经启动和运行了。
- 死锁检测:一个非常方便的使用场景是,你可以使用n个线程访问共享资源,在每次测试阶段的线程数目是不同的,并尝试产生死锁。
2 同步屏障CyclicBarrier
CyclicBarrier的字面意思是可循环使用(Cyclic)的屏障(Barrier)。它要做的事情是,让一组
线程到达一个屏障(也可以叫同步点)时被阻塞,直到最后一个线程到达屏障时,屏障才会开门,
所有被屏障拦截的线程才会继续运行。
我自己的理解CyclicBarrier非常类似集齐七颗龙珠召唤神龙,尤其CyclicBarrier(int parties,Runnable barrierAction),barrierAction就是那个神龙
CyclicBarrier默认的构造方法是CyclicBarrier(int parties),其参数表示屏障拦截的线程数量,
每个线程调用await方法告诉CyclicBarrier我已经到达了屏障,然后当前线程被阻塞
示例:
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
|
package
com.tlk.chapter8;
import
java.util.concurrent.CyclicBarrier;
public
class
CyclicBarrierTest {
// 如果把new CyclicBarrier(2)修改成newCyclicBarrier(3),则主线程和子线程会永远等待,因为没有第三个线程执行await方法,
// 即没有第三个线程到达屏障,所以之前到达屏障的两个线程都不会继续执行。
static
CyclicBarrier c =
new
CyclicBarrier(
2
);
// 因为主线程和子线程的调度是由CPU决定的,两个线程都有可能先执行
public
static
void
main(String[] args) {
new
Thread(
new
Runnable() {
@Override
public
void
run() {
try
{
c.await();
}
catch
(Exception e) {
}
System.out.println(
1
);
}
}).start();
try
{
c.await();
}
catch
(Exception e) {
}
System.out.println(
2
);
}
}
|
CyclicBarrier还提供一个更高级的构造函数CyclicBarrier(int parties,Runnable barrier-
Action),用于在线程到达屏障时,优先执行barrierAction,方便处理更复杂的业务场景
示例:
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
|
package
com.tlk.chapter8;
import
java.util.concurrent.CyclicBarrier;
public
class
CyclicBarrierTest2 {
//构造器CyclicBarrier(int parties, Runnable barrierAction),barrierAction有限执行
static
CyclicBarrier c =
new
CyclicBarrier(
2
,
new
A());
public
static
void
main(String[] args) {
new
Thread(
new
Runnable() {
@Override
public
void
run() {
try
{
c.await();
}
catch
(Exception e) {
}
System.out.println(
1
);
}
}).start();
try
{
c.await();
}
catch
(Exception e) {
}
System.out.println(
2
);
}
static
class
A
implements
Runnable {
@Override
public
void
run() {
System.out.println(
3
);
}
}
}
|
CyclicBarrier的应用场景
CyclicBarrier可以用于多线程计算数据,最后合并计算结果的场景,示例:
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
|
package
com.tlk.chapter8;
import
java.util.Map.Entry;
import
java.util.concurrent.BrokenBarrierException;
import
java.util.concurrent.ConcurrentHashMap;
import
java.util.concurrent.CyclicBarrier;
import
java.util.concurrent.Executor;
import
java.util.concurrent.Executors;
/**
* 银行流水处理服务类
* 用一个Excel保存了 用户所有银行流水,每个Sheet保存一个账户近一年的每笔银行流水,现在需要统计用户的日均银行
* 流水,先用多线程处理每个sheet里的银行流水,都执行完之后,得到每个sheet的日均银行流水,最
* 后,再用barrierAction用这些线程的计算结果,计算出整个Excel的日均银行流水
*/
public
class
BankWaterService
implements
Runnable {
/**
* 创建4个屏障,处理完之后执行当前类的run方法
*/
private
CyclicBarrier c =
new
CyclicBarrier(
4
,
this
);
/**
* 假设只有4个sheet,所以只启动4个线程
*/
private
Executor executor = Executors.newFixedThreadPool(
4
);
/**
* 保存每个sheet计算出的银流结果
*/
private
ConcurrentHashMap<String, Integer> sheetBankWaterCount =
new
ConcurrentHashMap<String, Integer>();
private
void
count() {
for
(
int
i =
0
; i <
4
; i++) {
executor.execute(
new
Runnable() {
@Override
public
void
run() {
// 计算当前sheet的银流数据,计算代码省略
sheetBankWaterCount.put(Thread.currentThread().getName(),
1
);
// 银流计算完成,插入一个屏障
try
{
c.await();
}
catch
(InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
});
}
}
@Override
public
void
run() {
int
result =
0
;
// 汇总每个sheet计算出的结果
for
(Entry<String, Integer> sheet : sheetBankWaterCount.entrySet()) {
result += sheet.getValue();
}
// 将结果输出
sheetBankWaterCount.put(
"result"
, result);
System.out.println(result);
}
public
static
void
main(String[] args) {
BankWaterService bankWaterCount =
new
BankWaterService();
bankWaterCount.count();
}
}
|
注意:以上代码用的是Executor而不是ExecutorService,最后没有shutdown();所以打印出结果后,main方法也会继续执行
CyclicBarrier和CountDownLatch的区别
CountDownLatch的计数器只能使用一次,而CyclicBarrier的计数器可以使用reset()方法重置。所
以CyclicBarrier能处理更为复杂的业务场景。例如,如果计算发生错误,可以重置计数器,并让线程
重新执行一次。
CyclicBarrier还提供其他有用的方法,比如getNumberWaiting方法可以获得Cyclic-Barrier阻塞的
线程数量。isBroken()方法用来了解阻塞的线程是否被中断。
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
|
package
com.tlk.chapter8;
import
java.util.concurrent.BrokenBarrierException;
import
java.util.concurrent.CyclicBarrier;
public
class
CyclicBarrierTest3 {
static
CyclicBarrier c =
new
CyclicBarrier(
3
);
public
static
void
main(String[] args) {
Thread thread =
new
Thread(
new
Runnable() {
@Override
public
void
run() {
try
{
c.await();
}
catch
(InterruptedException | BrokenBarrierException e) {
// e.printStackTrace();
}
}
});
thread.start();
thread.interrupt();
try
{
c.await();
}
catch
(InterruptedException | BrokenBarrierException e) {
// isBroken()方法用来了解阻塞的线程是否被中断
System.out.println(c.isBroken());
}
}
}
|
3 控制并发线程数的Semaphore
Semaphore(信号量)是用来控制同时访问特定资源的线程数量,它通过协调各个线程,以保证
合理的使用公共资源。
我感觉用驾考科目一考试来形容比较合适。北京玉马考场科目一考试只有100台机器,进入考场的只能有100个考生,当有考生考试结束时,排队的人才能进入考试。这里的考生就是线程,进入考场考试表示线程在执行,离开考场表示线程执行完成,考场有100人在考试,就表示线程被阻塞,不能被执行。
Semaphore应用场景
流量控制
特别是公用资源有限的应用场景,比如数据库连接。假如有一
个需求,要读取几万个文件的数据,因为都是IO密集型任务,我们可以启动几十个线程并发地读
取,但是如果读到内存后,还需要存储到数据库中,而数据库的连接数只有5个,这时我们必须控
制只有5个线程同时获取数据库连接保存数据,否则会报错无法获取数据库连接。
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
|
package
com.tlk.chapter8;
import
java.util.concurrent.ExecutorService;
import
java.util.concurrent.Executors;
import
java.util.concurrent.Semaphore;
public
class
SemaphoreTest {
private
static
final
int
THREAD_COUNT =
30
;
private
static
ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
private
static
Semaphore s =
new
Semaphore(
5
);
public
static
void
main(String[] args) {
for
(
int
i =
0
; i < THREAD_COUNT; i++) {
threadPool.execute(
new
Runnable() {
@Override
public
void
run() {
try
{
s.acquire();
System.out.println(
"save data"
);
//如果注释掉s.release(),打印5条save data后就会阻塞
s.release();
}
catch
(InterruptedException e) {
}
}
});
}
threadPool.shutdown();
}
}
|
其他方法
Semaphore还提供一些其他方法,具体如下。
·int availablePermits():返回此信号量中当前可用的许可证数。
·int getQueueLength():返回正在等待获取许可证的线程数。
·boolean hasQueuedThreads():是否有线程正在等待获取许可证。
·void reducePermits(int reduction):减少reduction个许可证,是个protected方法。
·Collection getQueuedThreads():返回所有等待获取许可证的线程集合,是个protected方法。
4 线程间交换数据的Exchanger
Exchanger(交换者)是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。
它提供一个同步点,在这个同步点,两个线程可以交换彼此的数据。这两个线程通过exchange方法
交换数据,如果第一个线程先执行exchange()方法,它会一直等待第二个线程也执行exchange方法,
当两个线程都到达同步点时,这两个线程就可以交换数据,将本线程生产出来的数据传递给对方。
代码示例:
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
|
package
com.tlk.chapter8;
import
java.util.concurrent.Exchanger;
import
java.util.concurrent.ExecutorService;
import
java.util.concurrent.Executors;
public
class
ExchangerTest {
private
static
final
Exchanger<String> exgr =
new
Exchanger<String>();
private
static
ExecutorService threadPool = Executors.newFixedThreadPool(
2
);
public
static
void
main(String[] args) {
threadPool.execute(
new
Runnable() {
@Override
public
void
run() {
try
{
String A =
"银行流水A"
;
// A录入银行流水数据
exgr.exchange(A);
}
catch
(InterruptedException e) {
}
}
});
threadPool.execute(
new
Runnable() {
@Override
public
void
run() {
try
{
String B =
"银行流水C"
;
// B录入银行流水数据
String C = exgr.exchange(
"B"
);
System.out.println(C);
System.out.println(
"A和B数据是否一致:"
+ C.equals(B) +
",A录入的是:"
+ C +
",B录入是:"
+ B);
}
catch
(InterruptedException e) {
}
}
});
threadPool.shutdown();
}
}
|
对于Exchanger理解不是太深,没怎么想到项目中真正要利用的场景,欢迎留言解答,谢谢!