[进阶]Java：线程池、处理Runnable、Callable任务、使用Executors得到线程池

news2024/10/7 12:21:23

什么是线程池？

线程池就是一个可以复用线程的技术。

不实用线程池的问题？

用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。

谁代表线程池？

JDK 5.0起提供了代表线程池的接口：ExecutorService。

如何得到线程池对象？

方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象。
方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

ThreadPoolExcutor构造器

参数一：corePoolSize ：指定线程池的核心线程的数量。
参数二：maximumPoolsize：指定线程池的最大线程数量。
参数三：keepAliveTime：指定临时线程的存活时间。
参数四：unit：指定临时线程存活的时问单位（秒、分、时、天）
参数五：workQueue：指定线程池的任务队列。
参数六：threadFactory：指定线程池的线程工厂。
参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）

创建代码演示如下：

public class ThreadPoolTest1 {
    public static void main(String[] args) {
        ExecutorService pool = new ThreadPoolExecutor(3,5,8,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
    }
}

线程池的注意事项

1.临时线程什么时候创建？

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

2.什么时候开始拒绝新任务？

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。

线程池处理Runnable任务

ExecutorService的常用方法

新任务拒绝策略

代码演示如下：

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "===> 输出666~");
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ThreadPoolTest1 {
    public static void main(String[] args) {
        // 通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
        pool.execute(target);// 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        // 到了临时线程的创建时机了
        pool.execute(target);
        pool.execute(target);
        // 到了新任务拒绝时机了
        pool.execute(target);

        //pool.shutdown(); // 等着线程池的任务全部执行完毕后，再关闭线程池
        //pool.shutdownNow(); // 立即关闭线程池！不管任务是否执行完毕！
    }
}

线程池处理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() + "求出了1-" + n + "的和是：" + sum;
    }
}

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception{
        // 1.通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        // 2.使用线程处理Callable任务。
        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();
    }
}

使用Executors得到线程池

Executors是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。

注意：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

代码演示如下：

public class ThreadPoolTest3 {
    public static void main(String[] args) throws Exception{
        // 1.通过ThreadPoolExecutor创建一个线程池对象
//        ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
//                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy());
        //1-2.通过Executors创建一个线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(13);
        //核心线程池数量到底配置多少？
        //计算密集型的任务：核心线程数量 = CPU的核数 + 1
        //IO密集型的任务：核心线程数量 = CPU核数 * 2


        // 2.使用线程处理Callable任务。
        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();
    }
}

Executors使用可能存在的陷阱