线程池处理Callable任务

Callable

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n){
        this.n = n;
    }

    @Override
    public  String call() throws Exception{
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum +=i;
        }
        return Thread.currentThread().getName() + "输出"+sum;
    }
}

//执行

import java.util.concurrent.*;

public class ThreadpoolTest2 {
    public static void main(String[] args) throws Exception {
        /** public ThreadPoolExecutor(int corePoolSize,
         int maximumPoolSize,
         long keepAliveTime,
         TimeUnit unit,
         BlockingQueue<Runnable> workQueue)*/
        //创建线程池对象
        ExecutorService pool =  new ThreadPoolExecutor(3,
                5,
                8,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(4),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());//线程池满了的拒绝策略
        //线程池处理Runnable任务
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());


        pool.shutdown();      //当所有线程都被处理完  关闭
        //pool.shutdownNow(); //立即关闭 返回未处理的线程
    }
}

结果