1 callable和future
一般情况，我们实现多线程都是Thread或者Runnable(后者比较多)，但是，这两种都是没返回值的，所以我们需要使用callable(有返回值的多线程)和future(获得线程的返回值)来实现了。
public class TestThread {
public static void main(String[] args) {
ThreadCount tc = null;
ExecutorService es = Executors.newCachedThreadPool();//线程池
CompletionService cs = new ExecutorCompletionService(es);
for(int i=0;i<4;i++){
tc = new ThreadCount(i+1);
cs.submit(tc);
}
// 添加结束，及时shutdown，不然主线程不会结束
es.shutdown();
int total = 0;
for(int i=0;i<4;i++){
try {
total+=cs.take().get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
System.out.println(total);
}
}
class ThreadCount implements Callable{
private int type;
ThreadCount(int type){
this.type = type;
}
@Override
public Integer call() throws Exception {
if(type==1){
System.out.println("C盘统计大小");
return 1;
}else if(type==2){
Thread.sleep(20000);
System.out.println("D盘统计大小");
return 2;
}else if(type==3){
System.out.println("E盘统计大小");
return 3;
}else if(type==4){
System.out.println("F盘统计大小");
return 4;
}
return null;
}
}
ps：一个需要注意的小细节，cs.take.get()获取返回值（这里阻塞？），是按照完成的顺序的，即上面案例返回顺序是CEFD
tips：
ExecutorCompletionService 是将 Executor和BlockQueue结合的jdk类，其实现的主要目的是：提交任务线程，每一个线程任务直线完成后，将返回值放在阻塞队列中，然后可以通过阻塞队列的take()方法返回 对应线程的执行结果！！
2. join阻塞——直接用join把线程5加入进去即可
直接用join把线程5加入进去即可
public static void main(String[] args) throws InterruptedException
{
Thread t1 = new Thread(new Worker("thread-1"));
Thread t2 = new Thread(new Worker("thread-2"));
Thread t3 = new Thread(new Worker("thread-3"));
Thread t4 = new Thread(new Worker("thread-4"));
Thread t5 = new Thread(new Worker("thread-5"));
t1.start();t2.start();t3.start();t4.start();
t1.join();t2.join();t3.join();t4.join();
t5.start();
t5.join();
}
或者，在t5的run：
t1.start();t2.start();t3.start();t4.start(); t1.join();t2.join();t3.join();t4.join();
t5线程中等待四个线程返回
3.用java.util.concurrent下的方法解决
用CountDownLatch : 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行
CountDownLatch 是计数器, 线程完成一个就记一个, 就像 报数一样, 只不过是递减的.
盗用别人的一个例子：
public class CountDownLatchDemo {
final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch=new CountDownLatch(2);//两个工人的协作
Worker worker1=new Worker("zhang san", 5000, latch);
Worker worker2=new Worker("li si", 8000, latch);
worker1.start();//
worker2.start();//
latch.await();//等待所有工人完成工作
System.out.println("all work done at "+sdf.format(new Date()));
}
static class Worker extends Thread{
String workerName;
int workTime;
CountDownLatch latch;
public Worker(String workerName ,int workTime ,CountDownLatch latch){
this.workerName=workerName;
this.workTime=workTime;
this.latch=latch;
}
public void run(){
System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));
doWork();//工作了
System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));
latch.countDown();//工人完成工作，计数器减一
}
private void doWork(){
try {
Thread.sleep(workTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
CyclicBarrier : N个线程 相互等待，任何一个线程完成之前，所有的线程都必须等待。
这样应该就清楚一点了，对于CountDownLatch来说，重点是那个 “一个线程” , 是它在等待， 而另外那N的线程在把 “某个事情” 做完之后可以继续等待，可以终止。而对于CyclicBarrier来说，重点是那 N个线程 ，他们之间任何一个没有完成，所有的线程都必须等待。
CyclicBarrier更像一个水闸, 线程执行就想水流, 在水闸处都会堵住, 等到水满(线程到齐)了, 才开始泄流.
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierTest {
public static void main(String[] args) {
//创建CyclicBarrier对象，
//并设置执行完一组5个线程的并发任务后，再执行MainTask任务
CyclicBarrier cb = new CyclicBarrier(5, new MainTask());
new SubTask("A", cb).start();
new SubTask("B", cb).start();
new SubTask("C", cb).start();
new SubTask("D", cb).start();
new SubTask("E", cb).start();
}
}
/**
* 最后执行的任务
*/
class MainTask implements Runnable {
public void run() {
//根据jdkdoc里的描述，哪个线程最后运行完，就执行下面的代码。
System.out.println("......执行最后的任务了......");
}
}
/**
* 一组并发任务
*/
class SubTask extends Thread {
private String name;
private CyclicBarrier cb;
SubTask(String name, CyclicBarrier cb) {
this.name = name;
this.cb = cb;
}
public void run() {
System.out.println("[并发任务" + name + "] 开始执行");
for (int i = 0; i < 999999; i++) ; //模拟耗时的任务
System.out.println("[并发任务" + name + "] 开始执行完毕，通知障碍器");
try {
//每执行完一项任务就通知障碍器
cb.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}
结果：
[并发任务A] 开始执行
[并发任务B] 开始执行
[并发任务B] 开始执行完毕，通知障碍器
[并发任务C] 开始执行
[并发任务C] 开始执行完毕，通知障碍器
[并发任务A] 开始执行完毕，通知障碍器
[并发任务D] 开始执行
[并发任务D] 开始执行完毕，通知障碍器
[并发任务E] 开始执行
[并发任务E] 开始执行完毕，通知障碍器
......执行最后的任务了......