java总结

常见的五种线程池的适应场景

newCachedThreadPool

用来创建一个可以无限扩大的线程池，适用于服务器负载较轻，执行很多短期异步任务。

newFixedThreadPool

创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于可以

预测线程数量的业务中，或者服务器负载较重，对当前线程数量进行限制。

newSingleThreadExecutor

创建一个单线程的线程池，适用于需要保证顺序执行各个任务，并且在任意时间点，不会有多个线程是

活动的场景。

newScheduledThreadPool

可以延时启动，定时启动的线程池，适用于需要多个后台线程执行周期任务的场景。

newWorkStealingPool

创建一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行，适用

于大耗时的操作，可以并行来执行

綫程池的7大參數 ThreadPoolExecutor

ThreadPoolExecutor参数含义

序号	名称	类型	含义
1	corePoolSize	int	核心线程池大小
2	maximumPoolSize	int	最大线程池大小
3	keepAliveTime	long	线程最大空闲时间
4	unit	TimeUnit	时间单位
5	workQueue	BlockingQueue	线程等待队列
6	threadFactory	ThreadFactory	线程创建工厂
7	handler	RejectedExecutionHandler	拒绝策略

任务调度算法

• 如果当前线程池线程个数小于corePoolSize则开启新线程
• 否则添加任务到阻塞队列
• 如果任务队列满了，则尝试新开启线程执行任务，如果线程>maximumPoolSize则执行RejectedExecutionHandler。

工作队列

1、无界队列：队列大小无限制，常用的为无界的LinkedBlockingQueue，当任务耗时较长时可能会导致大量新任务

在队列中堆积最终导致OOM。

2、有界队列：常用的有两类，一类是遵循FIFO原则的队列如ArrayBlockingQueue与有界的LinkedBlockingQueue，

另一类是优先级队列如PriorityBlockingQueue

> PriorityBlockingQueue中的优先级由任务的Comparator决定。

> 使用有界队列时队列大小需和线程池大小互相配合，线程池较小有界队列较大时可减少内存消耗，降低cpu使

用率和上下文切换，但是可能会限制系统吞吐量。

> 实际开发中一般应该使用有界队列。

3、同步移交队列：如果不希望任务在队列中等待而是希望将任务直接移交给工作线程，可使用SynchronousQueue

作为等待队列

> SynchronousQueue不是一个真正的队列，而是一种线程之间移交的机制。要将一个元素放入

SynchronousQueue中，必须有另一个线程正在等待接收这个元素。只有在使用无界线程池或者有饱和策略时才

建议使用该队列。

JAVA提供4种饱和策略

1、AbortPolicy直接抛出异常。 2、CallerRunsPolicy只用调用所在的线程运行任务。 3、DiscardOldestPolicy丢弃队列里最近的一个任务，并执行当前任务。 4、DiscardPolicy不处理，丢弃掉。

任务队列、核心线程数、最大线程数的逻辑关系

• 当线程数小于核心线程数时，创建线程
• 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列
• 当线程数大于等于核心线程数，且任务队列已满
  • 若线程数小于最大线程数，创建线程
  • 若线程数等于最大线程数，调用拒绝执行处理程序（默认效果为：抛出异常，拒绝任务）

阿里开发规范为什么不允许Executors快速创建线程池

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor方法，这样的处理方式让编程人员更加

明确线程池的运行规则，规避资源耗尽的风险

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

• FixedThreadPool和SingleThreadPool允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的

请求，从而导致OOM

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

线程池相关的主要方法

java.util.concurrent.ExecutorService是java线程池框架的主要接口，用Future保存任务的运行状态

及计算结果，主要方法有：

• void execute(Runnable)提交任务到线程池

• Future submit(Runnable)提交任务到线程池并返回Future

• Future submit(Runnable, T) 提交任务到线程池并返回Future, 第二个参数会作为计算结果封装到Future

• Future submit(Callable)提交任务到线程池并返回Future，call方法的计算结果会封装到Future

• List invokeAll(Collection extends Callable>) 批量提交任务并返回计算结果

• T invokeAny(Collectionextends Callable> tasks) 只执行其中一个任务并返回结果

• void shutdown() 线程池不再接受新任务，继续运行正在执行中的任务及等待中的任务

• List shutdownNow() 线程池不再接受新任务，继续运行正在执行中的任务，返回待执行的任务列表

线程池的关闭

shutdownNow：对正在执行的任务全部发出interrupt()，停止执行，对还未开始执行的任务全部取消，并且返回

还没开始的任务列表

shutdown：当调用shutdown后，线程池将不再接受新的任务，但也不会去强制终止已经提交或者正在执行中的任务

创建线程池的核心参数

• corePoolSize与maximumPoolSize。corePoolSize核心线程池大小，线程池刚启动时来一个任务就会创建一个线程去执行这个任务，直到达到corePoolSize个线程，这时再来的任务就会加到任务队列中去，直到任务队列满了，这时会尝试创建新的线程，但是总线程数量必须少于maximumPoolSize，如果线程也不能创建了，这时就会拒绝执行任务了
• workQueue 线程池所使用的任务阻塞队列，该阻塞队列的长度决定了能够缓冲任务的最大数量，queueCapacity任务队列容量
• keepAliveTime表示线程没有任务执行时最多保持多久时间会终止

参数的设置跟系统的负载有直接的关系，系统负载的相关参数：tasks每秒需要处理的最大任务数量；tasktime处理第个任务所需要的时间；responsetime系统允许任务最大的响应时间，比如每个任务的响应时间不得超过2秒。

如何合理配置线程池的大小

任务性质可分为：CPU密集型任务，IO密集型任务，混合型任务。

• 对于计算密集型的任务，一个有N cpu个处理器的系统通常通过使用一个N cpu+1个线程的线程池来得最优的利用率
• 对于IO密集型任务，包含了I/O和其他阻塞操作的任务，可以设置为2*N cpu
• 最优的线程池的大小等于 【（（线程等待时间+线程CPU时间）/线程CPU时间 ）* CPU数目 】
  • 比如平均每个线程CPU运行时间为0.5s，而线程等待时间（非CPU运行时间，比如IO）为1.5s，CPU核心数为8，

那么根据上面这个公式估算得到：((0.5+1.5)/0.5)*8=32

可以先将线程池大小设置为参考值，再观察任务运行情况和系统负载、资源利用率来进行适当调整。

Runtime.getRuntime().availableProcessors():int获取CPU的核数

线程通信

*

• 当线程在系统内运行时，线程的调度具有一定的透明性，程序通常无法精确控制线程的轮换执行，
• 但Java也有一些机制来保证线程协调执行。
• 线程间通信的模型有两种：共享内存和消息传递
• 多线程有什么用

• 1）发挥多核CPU的优势。随着工业的进步，现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的，
• 4核、8核甚至16核的也都不少见，如果是单线程的程序，那么在双核CPU上就浪费了50%，在4核CPU上就浪费
• 了75%。单核CPU上所谓的多线程那是假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换
• 得比较快，看着像多个线程"同时"运行罢了。多核CPU上的多线程才是真正的多线程，它能让你的多段逻辑
• 同时工作，多线程，可以真正发挥出多核CPU的优势来，达到充分利用CPU的目的。
• 2）防止阻塞。从程序运行效率的角度来看，单核CPU不但不会发挥出多线程的优势，反而会因为在单核CPU上
• 运行多线程导致线程上下文的切换，而降低程序整体的效率。但是单核CPU还是要应用多线程，就是为了防止
• 阻塞。试想，如果单核CPU使用单线程，那么只要这个线程阻塞了，比方说远程读取某个数据吧，对端迟迟未
• 返回又没有设置超时时间，那么你的整个程序在数据返回回来之前就停止运行了。多线程可以防止这个问题，
• 多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其它任务的执行。
• 3）便于建模。假设有一个大的任务A，单线程编程，那么就要考虑很多，建立整个程序模型比较麻烦。但是如
• 果把这个大的任务A分解成几个小任务，任务B、任务C、任务D，分别建立程序模型，并通过多线程分别运行这
• 几个任务，那就简单很多了。
• 什么是线程安全

• 如果你的代码在多线程下执行和在单线程下执行永远都能获得一样的结果，那么你的代码就是线程安全的。
• 1）不可变：像String、Integer、Long这些，都是final类型的类，任何一个线程都改变不了它们的值，要
• 改变除非新创建一个，因此这些不可变对象不需要任何同步手段就可以直接在多线程环境下使用。final能够
• 做出如下保证：当你创建一个对象时，使用final关键字能够使得另一个线程不会访问到处于“部分创建”的对
• 象。final类型的成员变量的值，包括那些用final引用指向的collections的对象，是读线程安全而无需使
• 用synchronization的
• 2）绝对线程安全：不管运行时环境如何，调用者都不需要额外的同步措施。要做到这一点通常需要付出许多
• 额外的代价，Java中标注自己是线程安全的类，实际上绝大多数都不是线程安全的，不过绝对线程安全的类
• ，Java中也有，比方说CopyOnWriteArrayList、CopyOnWriteArraySet
• 3）相对线程安全：相对线程安全也就是我们通常意义上所说的线程安全，像Vector这种，add、remove方
• 法都是原子操作，不会被打断，但也仅限于此，如果有个线程在遍历某个Vector、有个线程同时在add这个
• Vector，99%的情况下都会出现ConcurrentModificationException，也就是fail-fast机制。
• 4）线程非安全：ArrayList、LinkedList、HashMap等都是线程非安全的类
• 线程通信

方式一：使用 volatile 关键字

方式2：生产者消费者模式

Object类提供了线程间通信的方法：wait()、notify()、notifyaAll()，它们是多线程通信的基础，

而这种实现方式的思想自然是线程间通信。

注意： wait和notify必须配合synchronized使用，wait方法释放锁，sleep方法不释放锁

方式3：使用Lock和Condition控制线程通信

• await()导致当前线程等待，知道其它线程调用该条件变量的signal方法唤醒
• signal()唤醒Lock对象上等待的单个线程，如果有多个等待线程，则随机选中一个唤醒。只有当前线程

unlock后才能执行唤醒线程

• signalAll()唤醒Lock对象上所有的等待线程

方式4：CountDownLatch

jdk1.5后在java.util.concurrent包下提供了很多并发编程相关的工具类，简化了并发编程代码的书

写，CountDownLatch基于AQS框架，相当于也是维护了一个线程间共享变量state

方式5：LockSupport实现线程间的阻塞和唤醒

LockSupport是一种非常灵活的实现线程间阻塞和唤醒的工具，使用它不用关注是等待线程先进行还是

唤醒线程先运行，但是得知道线程的名字。