Callable与Futrue.get()等待线程执行完毕

1. 等待一个子线程执行完毕

public static void main(String[] args) {
		ExecutorService threadPool =  Executors.newSingleThreadExecutor();
		Future<String> future =
			threadPool.submit(
				new Callable<String>() {
					public String call() throws Exception {
						Thread.sleep(2000);
						return "hello";
					};
				}
		);
		System.out.println("等待线程执行");
		try {
			System.out.println("拿到结果：" + future.get());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
}

执行日志：

等待结果
拿到结果：hello
上述代码首先创建一个单线程池threadPool, threadPool提交submit一个Callable对象，这个Callbale对象里的call()方法相当于Runnable的Run()方法，是真正执行耗时任务的地方。
future.get()是一个阻塞等待 threadPool中的那个子线程执行完毕，并拿到结果：子线程返回的“hello”（Futrue<String>中的String表示返回一个字符串）。这里要区分的是future.get()阻塞主线程，但是线程池执行任务时，本身并不阻塞主线程的运行。

2. 等待线程池种的多个线程执行完毕

package testFuture;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class futrue {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
	
		SimpleDateFormat df = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");

		ExecutorService threadPool2 =  Executors.newFixedThreadPool(3);
		CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool2);
		System.out.println(
				df.format(new Date())+"开始添加3个任务");
		for(int i=1;i<=3;i++){
			final int seq = i;
			completionService.submit(new Callable<Integer>() {
				@Override
				public Integer call() throws Exception {
					Thread.sleep((5000));
					return seq;
				}
			});
		}
		for(int i=0;i<3;i++){
			try {
				System.out.println(
						completionService.take().get());
				System.out.println(
					df.format(new Date()));
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("over");
	}

	

}

执行日志：

2021-24-17 07:24:21开始添加3个任务
2
2021-24-17 07:24:26
1
2021-24-17 07:24:26
3
2021-24-17 07:24:26
over
 

上述我们创建了一个线程池，池子里有3个线程，接着我们用线程池创建一个CompletionService对象，向CompletionService里submit了3个任务，实质是为线程池添加了3个要执行的任务，每个任务耗时5秒。CompletionService.take()方法返回的是一个Futrue对象，同样Futrue.get()方法会阻塞等待其中一个线程执行完它所负责的任务，最终打印出了3，2,1的顺序，就是说任务3第一个被完成，接着Futrue.get()等待第2个任务完成，最后是第1个任务被完成。顺序不一样是由于多线程执行顺序的不确定性（CPU分时执行）。

等待所有任务执行完毕后，打印出了over.

一个常用应用场景是：当你用  “多线程池”  上传  “多张图片”  到服务器时，如果需要监听所有图片已被上传完毕，则可以使用这个Futrue。