Java并发实战：Callable+FutureTask实现多线程判分汇总

灰太狼 2022-06-07 01:48 70阅读 0赞

需求分析：

总结自己项目中用到多线程的地方，之前一级考试系统，在考生交卷的过程中，需要做很多事情，导致交卷过程很慢。当然不能让考生一直等待交卷这个过程，于是使用了Callable+FutureTask来优化交卷的速度。下面有优化的伪代码，仅供参考。

介绍callable和futuretask：

1.callable

Callable位于java.util.concurrent包下，它也是一个接口，在它里面也只声明了一个方法call()。一般情况下是配合ExecutorService来使用的，submit方法的参数。

2.futuretask

RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。FutureTask是Future接口的一个唯一实现类。

代码实现：

package test.thread;
    
    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 testFuture {
    	    public static void main(String[] args) {
    	        //使用Callable+FutureTask获取执行结果
    	    	//new 一个线程池
    	        ExecutorService executor = Executors.newCachedThreadPool();
    	         //开启3个判分的任务
    	        Task1 task1 = new Task1();
    	        Task2 task2 = new Task2();
    	        Task3 task3 = new Task3();
    	        //把任务放到futuretask中
    	        FutureTask<Integer> futureTask1 = new FutureTask<Integer>(task1);
    	        FutureTask<Integer> futureTask2 = new FutureTask<Integer>(task2);
    	        FutureTask<Integer> futureTask3 = new FutureTask<Integer>(task3);
    	        //1.子线程进行计算  线程执行 需要一个runable接口，futuretask实现了它
    	        executor.submit(futureTask1);
    	        executor.submit(futureTask2);
    	        executor.submit(futureTask3);
    	        executor.shutdown();
    
    	        try {
    	            Thread.sleep(1000);
    	        } catch (InterruptedException e1) {
    	            e1.printStackTrace();
    	        }
    	       
    	        try {
    	        	//2.返回结果  futureTask.get()
    	        	int danxuanti=futureTask1.get();
    	        	int panduanti=futureTask2.get();
    	        	int zuowenti=futureTask3.get();
    	        	int sum=danxuanti+panduanti+zuowenti;
    	            System.out.println("单选题子线程返回结果，主线程计算"+futureTask1.get());
    	            System.out.println("判断题子线程返回结果，主线程计算"+futureTask2.get());
    	            System.out.println("作文题子线程返回结果，主线程计算"+futureTask3.get());
    	            System.out.println("总分"+sum);
    	        } catch (InterruptedException e) {
    	            e.printStackTrace();
    	        } catch (ExecutionException e) {
    	            e.printStackTrace();
    	        }
    	        
    	    }
    	}
    	class Task1 implements Callable<Integer>{
    	    @Override
    	    public Integer call() throws Exception {
    			System.out.println("单选题判分中。。。");
    	    	Thread.sleep(3000);
    			return 10;
    	    }
    	}
    	class Task2 implements Callable<Integer>{
    
    		@Override
    		public Integer call() throws Exception {
    			System.out.println("判断题判分中。。。");
    			Thread.sleep(3000);
    			return 20;
    		}
    		
    	}
    	
    	class Task3 implements Callable<Integer>{
    
    		@Override
    		public Integer call() throws Exception {
    			System.out.println("作文题判分中。。。");
    			Thread.sleep(3000);
    			return 30;
    		}
    		
    	
    
    }

console返回结果

单选题判分中。。。
    判断题判分中。。。
    作文题判分中。。。
    单选题子线程返回结果，主线程计算10
    判断题子线程返回结果，主线程计算20
    作文题子线程返回结果，主线程计算30
    总分60