Java——多线程（7/9）：使用Executors得到线程池（Executors、代码演示、Executors使用可能存在的陷阱）

目录

Executors

代码演示

Executors使用可能存在的陷阱

---

Executors工具类实现线程池

• 实现类：ThreadPoolExecutor
• 工具类：Executors

Executors

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

方法名称	说明
public static ExecutorService newFixedThreadPool(int nThreads)	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉。
public staticScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

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

代码演示

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadPoolTest3 {
    public static void main(String[] args) throws Exception{
        //1、通过Executors创建一个线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(5);
        //核心线程数量的配置：
        //计算密集型的任务：核心线程数量 = 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());
    }
}

import java.util.concurrent.Callable;

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

    //重写call方法
    @Override
    public String call() throws Exception {
        //描述线程的任务，返回线程执行返回后的结果
        //需求：求1-n的和返回
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
    }
}

运行结果：

Executors使用可能存在的陷阱

• 大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors返回的线程池对象的弊端如下：

1）FixedThreadPool和SingleThreadPool：

允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。

2） CachedThreadPool：

允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

---

END 

---

学习自：黑马程序员——Java课程