两个带有线程池的方法分别执行两组线程任务，第二个方法需要等待第一组任务执行完毕

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zhaoqingkaitt/article/details/52228029

如下两种解决方案其中一个会影响效率，另一个可能会有未知风险，如果谁有更好的解决方案，谢谢分享。

package thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class CallableAndFuture {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		List<FutureTask<Integer>> taskList=method1();
		for(FutureTask<Integer> task:taskList){
			task.get();
		}
		System.out.println();
		System.out.println("*****任务一******全部执行结束****");
		System.out.println();
		method2();
		System.out.println();
		System.out.println("………………任务二…………是否执行结束？？？？？，一般情况还没有哦！");
		System.out.println();
	}
	
	public static List<FutureTask<Integer>>  method1(){
		ExecutorService executor = Executors.newCachedThreadPool();
		List<FutureTask<Integer>> taskList=new ArrayList<FutureTask<Integer>>();
		for(int i=0;i<5;i++){
			TheadTask1 task = new TheadTask1();
			FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
			executor.submit(futureTask);
			taskList.add(futureTask);
		}
		return taskList;
	}
	
	public static List<FutureTask<Integer>>  method2(){
		ExecutorService executor = Executors.newCachedThreadPool();
		List<FutureTask<Integer>> taskList=new ArrayList<FutureTask<Integer>>();
		for(int i=0;i<5;i++){
			TheadTask2 task = new TheadTask2();
			FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
			executor.submit(futureTask);
			taskList.add(futureTask);
		}
		return taskList;
	}
}

class TheadTask1 implements Callable<Integer> {
	@Override
	public Integer call() throws Exception {
		System.out.println("Task11111111111111111111111111111开始工作");
        Thread.sleep((long) (Math.random() * 6000));
		System.out.println("Task11111111111111111111111111111----结束工作"+Thread.currentThread().getName());
		return 1;
	}
}

class TheadTask2 implements Callable<Integer> {
	@Override
	public Integer call() throws Exception {
		System.out.println("Task22222222222222222222222222222开始工作");
        Thread.sleep((long) (Math.random() * 6000));
		System.out.println("Task22222222222222222222222222222----结束工作"+Thread.currentThread().getName());
		return 1;
	}
}

第二种方案：

package thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;


public class SemaPhore {
    private static final Semaphore semp = new Semaphore(1);
    public static void main(String[] args) throws InterruptedException {
        method();
    }
    
    
    
    public  static void method() throws InterruptedException{
    	method1();
    	//Thread.sleep(1000*2);
        method2();
    }
    
    public  static void method1() throws InterruptedException{
    		semp.release();
            ExecutorService exec = Executors.newCachedThreadPool();
        	for(int i=0;i<5;i++){
        		Task1 task1=new Task1();
                exec.execute(task1);
        	}
            // 退出线程池
            exec.shutdown();
            System.out.println("method1");
            while (true) {  
                if (exec.isTerminated()) {  
                	System.out.println("--method111--准备释放信号灯");
                	semp.acquire();
                    break;  
                }  
                Thread.sleep(200);  
            }  
    	// 
    }
    
    public  static void method2() throws InterruptedException{
			semp.release();
	    	// 线程池
	        ExecutorService exec = Executors.newCachedThreadPool();
	    	for(int i=0;i<5;i++){
	    		Task2 task2=new Task2();
		        exec.execute(task2);
	    	}
	        // 退出线程池
	        exec.shutdown();
            while (true) {  
                if (exec.isTerminated()) {  
                	System.out.println("--method222--准备释放信号灯");
                	semp.acquire();
                    break;  
                }  
                Thread.sleep(200);  
            }  
    }
}
class Task1 implements Runnable{
	
	

	@Override
	public void run() {
		try {
			System.out.println("Task11111111111111111111111111111开始工作");
            Thread.sleep((long) (Math.random() * 6000));
			System.out.println("Task11111111111111111111111111111----结束工作"+Thread.currentThread().getName());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
}
class Task2 implements Runnable{
	
	
	@Override
	public void run() {
		try {
			System.out.println("Task22222222222222222222222222222开始工作");
            Thread.sleep((long) (Math.random() * 6000));
			System.out.println("Task22222222222222222222222222222----结束工作"+Thread.currentThread().getName());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
}