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。

文章来源: blog.csdn.net，作者：冉航--小虾米，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/gaoxiaoweiandy/article/details/115799872