web前端开发自学要多久，JavaScript逻辑运算符与赋值运算符

而点开其他几个线程池到最后都可以发现，他们实际上用的就是这个ThreadPoolExecutor。我们把源代码粘过来分析，其实也就是这七大参数

/**

• Creates a new {@code ThreadPoolExecutor} with the given initial

• parameters.

• @param corePoolSize the number of threads to keep in the pool, even

•    if they are idle, unless {@code allowCoreThreadTimeOut} is set
  

• @param maximumPoolSize the maximum number of threads to allow in the

•    pool
  

• @param keepAliveTime when the number of threads is greater than

•    the core, this is the maximum time that excess idle threads
  

•    will wait for new tasks before terminating.
  

• @param unit the time unit for the {@code keepAliveTime} argument

• @param workQueue the queue to use for holding tasks before they are

•    executed.  This queue will hold only the {@code Runnable}
  

•    tasks submitted by the {@code execute} method.
  

• @param threadFactory the factory to use when the executor

•    creates a new thread
  

• @param handler the handler to use when execution is blocked

•    because the thread bounds and queue capacities are reached
  

• @throws IllegalArgumentException if one of the following holds:
  

•     {@code corePoolSize < 0}<br>
  

•     {@code keepAliveTime < 0}<br>
  

•     {@code maximumPoolSize <= 0}<br>
  

•     {@code maximumPoolSize < corePoolSize}
  

• @throws NullPointerException if {@code workQueue}

•     or {@code threadFactory} or {@code handler} is null
  

*/

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue workQueue,

ThreadFactory threadFactory,

RejectedExecutionHandler handler) {

if (corePoolSize < 0 ||

maximumPoolSize <= 0 ||

maximumPoolSize < corePoolSize ||

keepAliveTime < 0)

throw new IllegalArgumentException();

if (workQueue == null || threadFactory == null || handler == null)

throw new NullPointerException();

this.acc = System.getSecurityManager() == null ?

null :

AccessController.getContext();

this.corePoolSize = corePoolSize;

this.maximumPoolSize = maximumPoolSize;

this.workQueue = workQueue;

this.keepAliveTime = unit.toNanos(keepAliveTime);

this.threadFactory = threadFactory;

this.handler = handler;

}

毫无悬念，这就是最后一种方式，也是其他实现方式的基础。而用这种方式也是最容易控制，因为我们可以自由的设置参数。在阿里巴巴开发手册中也提到了

所以我们更需要去了解这七大参数，在平时用线程池的时候尽量去用ThreadPoolExecutor。而关于这七大参数我们简单概括就是

• corePoolSize: 线程池核心线程个数

• workQueue: 用于保存等待执行任务的阻塞队列

• maximunPoolSize: 线程池最大线程数量

• ThreadFactory: 创建线程的工厂

• RejectedExecutionHandler: 队列满，并且线程达到最大线程数量的时候，对新任务的处理策略

• keeyAliveTime: 空闲线程存活时间

• TimeUnit: 存活时间单位

3.1 而关于线程池最大线程数量，我们也有两种设置方式

1. CPU密集型

获得cpu的核数，不同的硬件不一样,设置核数的的线程数量。

我们可以通过代码Runtime.getRuntime().availableProcessors();获取，然后设置。

2. IO密集型

IO非常消耗资源，所以我们需要计算大型的IO程序任务有多少个。

一般来说，线程池最大值 > 大型任务的数量即可

一般设置大型任务的数量*2

这里我们用一个例子可以更好理解这些参数在线程池里面的位置和作用。

如图1.0，我们这是一个银行

我们一共有五个柜台，可以理解为线程池的最大线程数量，而其中有两个是在营业中，可以理解为线程池核心线程个数。而下面的等待厅可以理解为用于保存等待执行任务的阻塞队列。银行就是创建线程的工厂。

而关于空闲线程存活时间，我们可以理解为如图1.1这种情况，当五个营业中，却只有两个人需要被服务，而其他三个人一直处于等待的情况下，等了一个小时了，他们被通知下班了。这一个小时时间就可以说是空闲线程存活时间，而存活时间单位，顾名思义。

到现在我们就剩一个拒绝策略还没介绍，什么是拒绝策略呢？我们可以假设当银行五个柜台都有人在被服务，如图1.2。而等待厅这个时候也是充满了人，银行实在容不下人了。

这个时候对银行外面那个等待的人的处理策略就是拒绝策略。

我们同样了解之后用代码来测试一下：

public static void test05(){

ExecutorService threadPool = new ThreadPoolExecutor(

//核心线程数量

2,

//最大线程数量

5,

//空闲线程存活时间

3,

//存活单位

TimeUnit.SECONDS,

//这里我们使用大多数线程池都默认使用的阻塞队列，并使容量为3

new LinkedBlockingDeque<>(3),

Executors.defaultThreadFactory(),

//我们使用默认的线程池都默认用的拒绝策略

new ThreadPoolExecutor.AbortPolicy()

);

try {

//对线程进行执行十条打印任务

for(int i = 1; i <= 2; i++){

threadPool.execute(()->{

System.out.println(Thread.currentThread().getName()+“=>执行完毕！”);

});

}

} catch (Exception e) {

e.printStackTrace();

} finally {

//用完线程池一定要记得关闭

threadPool.shutdown();

}

}

我们执行打印两条任务，可以发现线程池只用到了我们的核心两条线程，相当于只有两个人需要被服务，所以我们就开了两个柜台。

pool-1-thread-1=>执行完毕！

pool-1-thread-2=>执行完毕！

但是在我们将打印任务改到大于5的时候，（我们改成8）我们可以发现线程池的五条线程都在使用了，人太多了，我们的银行需要都开放了来服务。

for(int i = 1; i <= 8; i++)

pool-1-thread-1=>执行完毕！

pool-1-thread-1=>执行完毕！

pool-1-thread-1=>执行完毕！

pool-1-thread-1=>执行完毕！

pool-1-thread-2=>执行完毕！

pool-1-thread-3=>执行完毕！

pool-1-thread-4=>执行完毕！

pool-1-thread-5=>执行完毕！

在我们改成大于8的时候，可以发现拒绝策略触发了。银行实在容纳不下了，所以我们把外面那个人用策略打发了。

for(int i = 1; i <= 9; i++)

在这里我们也可以得出一个结论：

线程池大小= 最大线程数 + 阻塞队列大小

在上面我们在使用的阻塞队列是大多数的线程池都使用的阻塞队列，所以就引发思考下面这个问题。

3.2 为什么大部分的线程池都用LinkedBlockingQueue？

• LinkedBlockingQueue 使用单向链表实现，在声明LinkedBlockingQueue的时候，可以不指定队列长度，长度为Integer.MAX_VALUE, 并且新建了一个Node对象,Node对象具有item，next变量，item用于存储元素，next指向链表下一个Node对象，在刚开始的时候链表的head,last都指向该Node对象，item、next都为null,新元素放在链表的尾部，并从头部取元素。取元素的时候只是一些指针的变化，LinkedBlockingQueue给put(放入元素),take(取元素)都声明了一把锁，放入和取互不影响，效率更高。

• ArrayBlockingQueue 使用数组实现，在声明的时候必须指定长度，如果长度太大，造成内存浪费，长度太小，并发性能不高，如果数组满了，就无法放入元素，除非有其他线程取出元素，放入和取出都使用同一把锁，因此存在竞争，效率比LinkedBlockingQueue低。

4 四种策略

---

我们在使用ThreadPoolExecutor的时候是可以自己选择拒绝策略的，而拒绝策略我们所知道的有四种。

• AbortPolicy（被拒绝了抛出异常）

• CallerRunsPolicy(使用调用者所在线程执行，就是哪里来的回哪里去)

• DiscardOldestPolicy(尝试去竞争第一个，失败了也不抛异常)

• DiscardPolicy(默默丢弃、不抛异常)

4.1 AbortPolicy

我们在上面使用的就是AbortPolicy拒绝策略，在执行打印任务超出线程池大小的时候，抛出了异常。

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Web前端开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：前端）

理了一份《2024年Web前端开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

[外链图片转存中…(img-vT3isxUu-1710898830237)]
[外链图片转存中…(img-T2oqjJv5-1710898830238)]
[外链图片转存中…(img-1isihJrA-1710898830238)]
[外链图片转存中…(img-S62brtJy-1710898830239)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：前端）
[外链图片转存中…(img-1WzxaT3Q-1710898830239)]