使用工具类Exectors创建线程池

大型并发项目不能使用Executors 通过ThreadPoolExector的方式

核心线程配置方式:

计算密集型的任务核心线程数量 =CPU的核数 + 1
IO密集型的任务核心线程数量 =CPU的核数*2

演示:

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 ThreadpoolTest3 {
    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());//线程池满了的拒绝策略
        */
        //使用工具类创建线程池
        //大型并发项目 不能使用Executors  通过ThreadPoolExector的方式
        ExecutorService pool = Executors.newFixedThreadPool(3);
        //计算密集型的任务  核心线程数量 =CPU的核数 + 1
        //IO密集型的任务 核心线程数量 =CPU的核数*2


        //线程池处理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(); //立即关闭 返回未处理的线程
    }
}

效果: