多线程学习—5-线程池的其他组件

前言

​ 多线程的基础功能已经总结完了,还剩几个jdk为我们提供的组件来配合不同的使用场景。今天总结下使用方法,源码等有时间再深究吧。

Timer

Timer的作用

  • 执行定时任务。
    • 计划时间晚于当前时间:未来执行
    • 计划时间早于当前时间:立即执行
    • 允许多个任务同时执行
  • cancle
    • timer的cancle,清除所有的定时任务
    • timeTask的cancle,清除某一个任务

CountDownLatch

​ 用”中式英语翻译”就是当”计数未完成时一直锁住”,即规定的线程个数达到预期的状态时触发事件,让其他线程得以继续工作。我觉得还是比较实用的,在”汇总”工作时经常用到。

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 MyThread;
import java.util.concurrent.CountDownLatch;
/**
* Created by yuhang on 2016/12/5.
*/
public class MyThread11 extends Thread {
private CountDownLatch cdl;
private int sleepSecond;
public MyThread11(String name, CountDownLatch cdl, int sleepSecond) {
super(name);
this.cdl = cdl;
this.sleepSecond = sleepSecond;
}
public void run() {
try {
System.out.println(this.getName() + "启动了 !");
long time = System.currentTimeMillis();
Thread.sleep(sleepSecond * 1000);
cdl.countDown();
System.out.println(this.getName() + "执行完了,时间为" + (System.currentTimeMillis() - time) / 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private static class DoneThread extends Thread {
private CountDownLatch cdl;
public DoneThread(String name, CountDownLatch cdl) {
super(name);
this.cdl = cdl;
}
public void run() {
try {
System.out.println(this.getName() + "要等待了!");
long time = System.currentTimeMillis();
cdl.await();//等待countDown()
System.out.println(this.getName() + "等待完了, 等待时间为:" + (System.currentTimeMillis() - time) / 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws Exception {
//改变参数来体验被唤醒的情况
CountDownLatch cdl = new CountDownLatch(3);
DoneThread dt0 = new DoneThread("DoneThread1", cdl);
DoneThread dt1 = new DoneThread("DoneThread2", cdl);
dt0.start();
dt1.start();
MyThread11 wt0 = new MyThread11("WorkThread1", cdl, 2);
MyThread11 wt1 = new MyThread11("WorkThread2", cdl, 3);
MyThread11 wt2 = new MyThread11("WorkThread3", cdl, 4);
wt0.start();
wt1.start();
wt2.start();
}
}

SemaPhore

​ SemaPhore有两个主要的方法:acquire和release。分别是获得和释放信号,在创建SemaPhore指定一个int型的参数,当acquire等于这个数时,后来的acquire方法会被阻塞住,直到release信号时。注意SemaPhore是可以指定公平锁的。

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
package MyThread;
import java.util.concurrent.Semaphore;
/**
* Created by yuhang on 2016/12/5.
*/
public class MyThread12 {
public static void main(String[] args) {
//可以改变参数来控制允许并发的数量
final Semaphore semaphore = new Semaphore(4);
Runnable runnable = () -> {
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + "获得了信号量 !");
long time = System.currentTimeMillis();
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName() + "释放了信号量,时间为" + (System.currentTimeMillis() - time) / 1000 + " 秒");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
};
Thread[] threads = new Thread[10];
for (int i = 0; i < threads.length; i++)
threads[i] = new Thread(runnable);
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
}
}

CyclicBarrier

​ 再次用”用中式英语”理解下字面意思:将给定数量的成员集中在一个屏障点上,然后在统一执行后面的操作。意思即是若干个线程一起执行,当数量达到某个条件时,线程阻塞,等某个任务执行完时,再继续执行await()以后的代码。和前面的CountDownLatch有点像,但是是完全不同的,先运行下代码,再来总结不同点。

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
package MyThread;
import java.util.concurrent.CyclicBarrier;
/**
* Created by yuhang on 2016/12/5.
*/
public class MyThread14 {
public static class CyclicBarrierThread extends Thread {
private CyclicBarrier cb;
private int sleepSecond;
public CyclicBarrierThread(CyclicBarrier cb, int sleepSecond) {
this.cb = cb;
this.sleepSecond = sleepSecond;
}
public void run() {
try {
System.out.println(this.getName() + "运行了");
Thread.sleep(sleepSecond * 1000);
System.out.println(this.getName() + "准备等待了, 时间为" + System.currentTimeMillis());
cb.await();
System.out.println(this.getName() + "结束等待了, 时间为" + System.currentTimeMillis());
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Runnable runnable = () -> System.out.println("CyclicBarrier的所有线程await()结束了,我运行了, 时间为" + System.currentTimeMillis());
//三个屏障
CyclicBarrier cb = new CyclicBarrier(3, runnable);
CyclicBarrierThread cbt0 = new CyclicBarrierThread(cb, 3);
CyclicBarrierThread cbt1 = new CyclicBarrierThread(cb, 6);
CyclicBarrierThread cbt2 = new CyclicBarrierThread(cb, 9);
cbt0.start();
cbt1.start();
cbt2.start();
}
}

CyclicBarrier和CountDownLatch的区别

根据上面两个demo其实可以理解:

  • countDown()方法执行仅仅是给”计数器减一”,然后当前线程不阻塞,继续运行下面的代码,当”计数器为0”时,会触发多个任务;而CyclicBarrier是”计数器”运行到”屏障”前必须阻塞,知道屏障内的代码执行完,前面的线程才会继续执行,并且仅仅只唤醒了一个”屏障内的线程”。
  • CyclicBarrier可重用,CountDownLatch不可重用,计数值为0该CountDownLatch就不可再用了。

理解其原理,区别自然是很简单就能说出来了。

Future和Callable

​ 比较简单。跑一遍代码,使用它们的优点是,如果先执行A方法再执行B方法,但是B方法需要10S,A方法需要5S,传统方法等A执行完,再执行B,一共需要15s,造成了时间上的浪费,使用Future和Callable能够并行执行,自然不会存在这样的问题了,传统多线程也能做到,只是不好取的返回值。

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
package MyThread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* Created by yuhang on 2016/12/5.
*/
public class MyThread15 {
public static class CallableThread implements Callable<String> {
public String call() throws Exception {
System.out.println("进入CallableThread的call()方法, 开始睡觉, 睡觉时间为" + System.currentTimeMillis());
Thread.sleep(10000);
return "123";
}
}
public static void main(String[] args) throws Exception {
ExecutorService es = Executors.newCachedThreadPool();
CallableThread ct = new CallableThread();
Future<String> f = es.submit(ct);
es.shutdown();
Thread.sleep(5000);
System.out.println("主线程等待5秒, 当前时间为" + System.currentTimeMillis());
String str = f.get();
System.out.println("Future已拿到数据, str = " + str + ", 当前时间为" + System.currentTimeMillis());
}
}

小结

多线程常用知识终于总结完了,其实也没那么复杂,对吧?还是那句话,坚持就是胜利!

坚持原创技术分享,您的支持将鼓励我继续创作!

热评文章