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