[转] 《Java并发编程的艺术》笔记

转自https://gitee.com/Corvey/note

作者:Corvey


第一章 并发编程的挑战

第二章 Java并发机制的底层实现原理

  • volatile的两条实现原则:
    1. Lock前缀指令会引起处理器缓存回写到内存
    2. 一个处理器的缓存回写到内存会导致其他处理器的缓存无效。
  • volatile的使用优化:共享变量会被频繁读写时,可以通过追加为64字节以提高并发编程的效率。因为目前主流处理器高速缓存行是64个字节宽,不支持部分填充缓存行,通过追加到64字节的方式填满高速缓冲区的缓存行,避免各元素加载到同一缓存行而互相锁定。(Java7后可能不生效,因为Java7更智能,会淘汰或重新排列无用字段,需要使用其他追加字节的方式
  • Java对象头
长度 内容 说明
32/64bit Mark Word 存储对象的hashCode或锁信息等
32/64bit Class Metadata Address 存储到对象类型数据的指针
32/64bit Array Length 数组的长度(仅当当前对象为数组时存在)
  • CAS操作,即Compare And Swap,比较并交换。CAS操作需要输入两个数值,一个旧值(期望操作前的值)和一个新值,在操作期间先比较旧值有没有发生变化,如果没有则交换成新值,否则不交换。
  • 锁有4种状态,级别从低到高依次是:无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态。这几种状态会随着竞争情况逐渐升级,只升不降。
  • 偏向锁
    • 当一个线程访问同步块并获取锁时,会在对象头和栈帧中的所记录里存储锁偏向的线程ID,以后该线程再次加锁解锁时不需要进行CAS操作,只需简单地测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。
    • 偏向锁使用了一种等到竞争出现才释放锁的机制,所以当其他线程常识竞争偏向锁时,豉油偏向锁的线程才会释放锁。
    • 偏向锁的撤销,需要等待全局安全点(在这个时间点上没有正在执行的字节码)。它会首先暂停拥有偏向锁的线程,然后检查豉油偏向锁的线程是否活着,如果线程不处于活动状态,则将对象头设置成无锁状态;如果线程仍然活着,拥有偏向锁的栈会被执行,遍历偏向对象的锁记录,栈中的所记录和对象头的Mark Word要么重新偏向于其他线程,要么恢复到无锁或者标记对象不适合作为偏向锁,最后唤醒暂停的线程。
    • 偏向锁默认启动,但是它在应用程序启动几秒钟之后才激活,如有必要可以使用JVM参数来关闭延迟:-XX:BiasedLockingStartupDelay=0。如果确定应用程序里所有的锁通常情况下处于竞争状态,可以通过JVM参数来关闭偏向锁:-XX:-UseBiasedLocking=false,那么程序默认会进入轻量级锁状态。
  • 轻量级锁
    • 线程在执行同步块之前,JVM会现在当前线程的栈帧中创建用于存储锁记录的空间,并将对象头中的Mark Word复制到锁记录中(Displaced Mark Word)。然后线程尝试使用CAS将对象头中的Mark Word奇幻为指向锁记录的指针。如果成功则当前线程获得锁,否则说明其他线程竞争锁,当前线程尝试使用自旋来获取锁。
    • 轻量级锁解锁时,会使用原子的CAS操作将Displaced Mark Word替换回到对象头,如果成功则表示没有竞争发生,否则表示当前锁存在竞争,锁会升级为重量级锁。
  • 重量级锁
    • 其他线程视图获取锁时都被阻塞,持有锁的线程释放锁之后唤醒这些线程,被唤醒的线程再抢。
  • 锁的优缺点对比
优点 缺点 适用场景
偏向锁 加锁和解锁无需额外的消耗,和执行非同步方法相比仅存在纳秒级的差距 如果线程间存在锁竞争,会带来额外的锁撤销的消耗 适用于只有一个线程访问同步块场景
轻量级锁 竞争的线程不会阻塞,提高了程序的响应速度 如果始终得不到锁竞争的线程,使用自旋会消耗CPU 追求响应时间,同步块执行速度非常快
重量级锁 线程竞争不适用自旋,不会消耗CPU 线程阻塞,响应时间缓慢 追求吞吐量,同步块执行速度较慢
  • 使用循环CAS实现原子操作,JDK的并发包提供了一些类支持原子操作,如AtomicInteger等。
  • CAS实现原子操作的三大问题
    1. ABA问题。一个值从A变成B又变成A,使用CAS检查时以为没有变化,但实际上却变化了。解决思路是使用版本号。
    2. 循环时长长,开销大。
    3. 只能保证一个共享变量的原子操作。(Java1.5以后,JDK提供了AtomicReference类来保证引用对象之间的原子性,可以把多个变量放在一个对象里来进行CAS操作)

第三章 Java内存模型

  • 并发编程模型的两个关键问题:线程之间如何通信及线程之间如何同步
  • 在命令式编程中,线程之间的通信机制有两种:共享内存和消息传递。
  • 内存屏障类型表
屏障类型 说明
LoadLoad Barriers 确保Load1数据的装载先于Load2及所有后序装置指令的装载
StoreStore Barriers 确保Store1数据对其他处理器可见(刷新到内存)先于Store2及所有后序存储指令的存储
LoadStore Barriers 确保Load1数据装载先于Store2及所有后序的存储指令刷新到内存
StoreLoad Barriers 确保Store1数据对其他处理器变得可见(指刷新到内存)先于Load2及所有后序装载指令的装载。StoreLoad Barriers会使改屏障之前的所有内存访问指令(存储和装载指令)完成之后,才执行该屏障之后的内存访问指令
  • 编译器、runtime和处理器都必须遵守as-if-serial语义,即不管怎么重排序,(单线程)程序的执行结果不能被改变。

volatile的内存语义

  • volatile变量自身具有以下特性:
    • 可见性:对一个volatile变量的读,总是能看到(任意线程)对这个volatile变量最后的写入。
    • 原子性:对任意单个volatile变量的读/写具有原子性,但类似于volatile++这种复合操作不具有原子性。
  • volatile写-读的内存语义:
    • 当写一个volatile变量时,JMM会把该线程对应的本地内存中的共享变量值刷新到主内存。
    • 当读一个volatile变量时,JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。
  • JMM内存屏障插入策略:
    • 在每个volatile写操作前后分别插入StoreStore、StoreLoad屏障。
    • 在每个volatile读操作后面插入LoadLoad、LoadStore屏障。

锁的内存语义

  • 当线程获取锁时,JMM会把该线程对应的本地内存置为无效。
  • 当线程释放锁时,JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。
  • 公平锁和非公平锁的内存语义:
    • 公平锁和非公平锁释放时,最后都要写一个volatile变量state。
    • 公平锁获取时,首先会去读volatile变量。
    • 非公平锁获取时,首先会用CAS操作更新volatile变量,这个操作同时具有volatile读/写的内存语义。

final域的内存语义

  • 对于final域,编译器和处理器要遵循两个重排序规则。
    • 在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序。
    • 初次读一个包含final域的对象的应用,与随后初次读这个final域,这两个操作之间不能重排序。
  • 读final域的重排序规则可以确保:在读一个对象的final域之前,一定会先读包含这个final域的对象的引用。
  • 写final域的重排序规则可以确保:在对象引用为任意线程可见之前,对象的final域已经被正确初始化。(前提是对象引用不能在构造函数中逸出

第四章 Java并发编程基础

  • 线程的优先级仅仅是一部分决定因素,因为线程的切换具有随机性,而且针对不同的系统而言,优先级这个概念可能就不存在,其仅仅是决定程序设计的衡量的一个标准。
  • 等待/通知的经典范式
    • 等待方遵循如下原则:
      1. 获取对象的锁
      2. 如果条件不满足,那么调用对象的wait()方法,被通知后仍要检查条件。
      3. 条件满足则执行对应的逻辑。
    • 通知方遵循如下原则:
      1. 获得对象的锁。
      2. 改变条件。
      3. 通知所有等待在对象上的线程。

第五章 Java中的锁

  • Lock接口提供的synchronized关键字不具备的主要特性
特性 描述
尝试非阻塞地获取锁 当前线程尝试获取锁,如果这一时刻锁没有被其他线程获取到,则成功获取并持有锁
能被中断地获取锁 获取到锁的线程能够相应中断,当获取到锁的线程被中断时,中断异常将会被抛出,同时锁会被释放
超时获取锁 在指定的截止时间之前获取锁,如果截止时间到了仍旧无法获取锁,则返回

队列同步器(AbstractQueuedSynchronizer)

  • 同步器提供如下3个方法来访问或修改同步状态(int成员变量):
    • getState():获取当前同步状态
    • setState(int newState):设置当前同步状态
    • compareAndSetState(int expect, int update):使用CAS设置当前状态,该方法能够保证状态设置的原子性。
  • 同步器可重写的方法
方法名称 描述
protected boolean tryAcquire(int arg) 独占式获取同步状态,实现该方法需要查询当前状态并判断同步状态是否符合预期,然后再进行CAS设置同步状态
protected boolean tryRelease(int arg) 独占式释放同步状态,等待获取同步状态的线程将有机会获取同步状态
protected int tryAcquireShared(int arg) 共享式获取同步状态,返回大于等于0的值,表示获取成功,反之失败
protected boolean tryReleaseShared(int arg) 共享式释放同步状态
protected boolean isHeldExclusively() 当前同步器是否在独占模式下被线程占用,一般该方法表示是否被当前线程所独占
  • 同步器提供的模板方法

[转] 《Java并发编程的艺术》笔记_第1张图片

  • 同步队列及等待队列的节点属性类型与名称以及描述

[转] 《Java并发编程的艺术》笔记_第2张图片

  • 同步队列中的结点只有当其前驱结点为头结点时,才尝试获取同步状态。
  • 读写锁的同步状态高16位表示读状态、低16位表示写状态。

LockSupport

  • 当需要阻塞或唤醒一个线程的时候,都会使用LockSupport工具类来完成相应工作。LockSupport定义了一组公共静态方法,这些方法提供了最基本的线程阻塞和唤醒功能,而LockSupport也成为了构建同步组建的基础工具。
  • LockSupport提供的阻塞和唤醒方法(其中参数blocker是用来标识当前线程在等待的对象,便于问题排查和系统监控)
方法名称 描述
void park(Object blocker) 阻塞当前线程,如果调用unpark方法或者当前线程被终端,才能从park方法返回
void parkNanos(Object blocker, long nanos) 阻塞当前线程,最长不超过nanos纳秒,返回条件在park的基础上增加了超时返回
void parkUntil(Object blocker, long deadline) 阻塞当前线程,知道deadline时间
void unpark(Thread thread) 唤醒处于阻塞状态的线程thread

第六章 Java并发容器和框架

  • ConcurrentHashMap使用锁分段技术,将数据非诚一段一段地存储,然后给每一段数据配一把锁,当一个线程占用锁访问其中一个段数据的时候,其他段的数据也能被其他线程访问。
  • ConcurrentLinkedQueue非阻塞的线程安全队列

阻塞队列

  • 阻塞队列(BlockingQueue)是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。
    1. 支持阻塞的插入方法:当队列满时,队列会阻塞插入元素的线程,知道队列不满。
    2. 支持阻塞的移除方法:当队列空时,获取元素的线程会等待队列变为非空。
  • 插入和移除操作的4种处理方式
方法/处理方式 抛出异常 返回特殊值 一直阻塞 超时退出
插入方法 add(e) offer(e) put(e) offer(e, time, unit)
移除方法 remove() poll() take() poll(time, unit)
检查方法 element() peek() 不可用 不可用
  • 抛出异常:当队列满时,如果再往队列里插入元素会抛出IllegalStateException("Queue full")异常。当队列空时,从队列里获取元素会抛出NoSuchElementException异常。
  • 返回特殊值:当往队列插入元素时,会返回元素是否插入成功,成功返回true。如果是移除方法,则从队列里取出一个元素,如果没有则返回null。
  • 一直阻塞:当阻塞队列满时,如果生产者线程往队列里put元素,队列会一直阻塞生产者线程,知道队列可用或者响应中断退出。当队列空时,如果消费者线程从队列列take元素,队列会阻塞消费者线程,知道队列不为空。
  • 超时退出:当阻塞队列满时,如果生产者线程往队列里插入元素,队列会阻塞生产者线程一段时间,如果超时则退出。
  • JDK7提供了7个阻塞队列:
    1. ArrayBlockingQueue:用数组实现的有界阻塞队列,按FIFO原则对元素进行排序。
    2. LinkedBlockingQueue:用链表实现的有界阻塞队列,默认和最大长度为Integer.MAX_VALUE,按FIFO原则对元素进行排序。
    3. PriorityBlockingQueue:支持优先级的无界阻塞队列,默认情况下元素采取自然顺序升序排列。不保证同优先级元素的顺序。
    4. DelayQueue:支持延时获取元素的无界阻塞队列。队列使用PriorityQueue实现,队列中的元素必须实现Delayed接口,在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。可应用于:
      • 缓存系统的设计:用DelayQueue保存缓存元素的有效期,使用一个线程循环查询DelayQueue,一旦能从DelayQueue中获取元素表示缓存有效期到了。
      • 定时任务调度:使用DelayQueue保存当天将会执行的任务和执行时间,一旦从DelayQueue中获取到任务就开始执行,比如TimerQueue就是使用DelayQueue实现的。
    5. SynchronousQueue:不存储元素的阻塞队列。每一个put操作必须等待一个take操作,否则不能继续添加元素。
    6. LinkedTransferQueue:链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列,LinkedTransferQueue多了tryTransfer和transfer方法。
      • transfer方法:如果当前有消费者正在等待接收元素,transfer方法可以把生产者传入的元素立刻传给消费者。如果没有消费者在等待接收元素,则将元素存放在队列tail节点并等到钙元素被消费者消费了才返回。
      • tryTransfer方法:如果没有消费者等待接收元素,则立即返回false。
    7. LinkedBlockingDeque:链表结构组成的双向阻塞队列。

Fork/Join框架

  • Fork/Join框架是一个用于并行执行任务的框架,是一个把大任务分隔成若干个小任务,最终汇总每个小任务结果后得到大人物结果的框架。
  • 工作窃取算法:假如我们需要做一个比较大的任务,我们可以把这个任务分割为若干互不依赖的子任务,为了减少线程间的竞争,于是把这些子任务分别放到不同的队列里,并为每个队列创建一个单独的线程来执行队列里的任务,线程和队列一一对应,比如A线程负责处理A队列里的任务。但是有的线程会先把自己队列里的任务干完,而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着,不如去帮其他线程干活,于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列,所以为了减少窃取任务线程和被窃取任务线程之间的竞争,通常会使用双端队列,被窃取任务线程永远从双端队列的头部拿任务执行,而窃取任务的线程永远从双端队列的尾部拿任务执行。工作窃取算法的优点是充分利用线程进行并行计算,并减少了线程间的竞争,其缺点是在某些情况下还是存在竞争,比如双端队列里只有一个任务时。并且消耗了更多的系统资源,比如创建多个线程和多个双端队列。
  • ForkJoinTask:我们要使用ForkJoin框架,必须首先创建一个ForkJoin任务。它提供在任务中执行fork()和join()操作的机制,通常情况下我们不需要直接继承ForkJoinTask类,而只需要继承它的子类,Fork/Join框架提供了以下两个子类:
    • RecursiveAction:用于没有返回结果的任务。
    • RecursiveTask :用于有返回结果的任务。
  • ForkJoinPool :ForkJoinTask需要通过ForkJoinPool来执行,任务分割出的子任务会添加到当前工作线程所维护的双端队列中,进入队列的头部。当一个工作线程的队列里暂时没有任务时,它会随机从其他工作线程的队列的尾部获取一个任务。
  • ForkJoinTask在执行的时候可能会抛出异常,但是我们没办法在主线程里直接捕获异常,所以ForkJoinTask提供了isCompletedAbnormally()方法来检查任务是否一件抛出异常或已经被取消了,并且可以通过ForkJoinTask的getException方法获取异常。其中,getException方法返回Throwable对象,如果任务被取消了则返回CancellationException,如果任务没有完成或者没有抛出异常则返回null。

第七章 Java中的13个原子操作类(Ps:认真数了一下发现只有12个)

  • 原子更新方式
    • 原子更新基本类型
    • 原子更新数组
    • 原子更新引用
    • 原子更新属性(字段) *原子更新基本类型
    • AtomicBoolean :原子更新布尔类型
    • AtomicInteger: 原子更新整型
    • AtomicLong: 原子更新长整型
  • 原子更新数组
    • AtomicIntegerArray :原子更新整型数组里的元素
    • AtomicLongArray :原子更新长整型数组里的元素
    • AtomicReferenceArray : 原子更新引用类型数组的元素
  • 原子更新引用类型
    • AtomicReference :原子更新引用类型
    • AtomicReferenceFieldUpdater :原子更新引用类型里的字段
    • AtomicMarkableReference:原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和应用类型
  • 原子更新字段类
    • AtomicIntegerFieldUpdater:原子更新整型的字段的更新器
    • AtomicLongFieldUpdater:原子更新长整型字段的更新器
    • AtomicStampedReference:原子更新带有版本号的引用类型。该类将整型数值与引用关联起来,可用于原子的更新数据和数据的版本号,可以解决使用CAS进行原子更新时可能出现的ABA问题。

第八章 Java中的并发工具类

CountDownLatch

  • CountDownLatch允许一个或多个线程等待其他线程完成操作。
  • CountDownLatch的构造函数接收一个int类型的参数作为计数器,如果你想等待N个点完成,就传入N。
  • 每次调用CountDownLatch的countDown方法时,N就减1,CountDownLatch的await方法会阻塞当前线程,知道N变成0。

CyclicBarrier

  • CyclicBarrier的作用是让一组线程到达一个屏障(也可以称之为同步点)时被阻塞,知道最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才能继续运行。
  • CyclicBarrier(int parties)构造函数接收一个int参数用来设置拦截线程的数量,还有一个更高级的构造函数CyclicBarrier(int parties, Runnable barrierAction)设定第一个到达屏障的线程执行barrierAction。
  • getNumberWaiting方法可以获得CyclicBarrier阻塞的线程数量,isBroken()方法用来了解阻塞的线程是否被中断。

Semaphore

  • Semaphore(信号量)用来控制同时访问特定资源的线程数量,通过协调各个线程以保证合理的使用公共资源。
  • Semaphore(int permits)构造方法接收一个int参数,表示可用的许可证数量。
  • 每次线程使用Semaphore的acquire()方法获取一个许可证,用完后调用release()方法归还。
  • 其他方法
    • intavailablePermits():返回此信号量中当前可用的许可证数。
    • intgetQueueLength():返回正在等待获取许可证的线程数。
    • booleanhasQueuedThreads():是否有线程正在等待获取许可证。
    • void reducePermits(int reduction):减少reduction个许可证,是个protected方法。
    • Collection getQueuedThreads():返回所有等待获取许可证的线程集合,是个protected方法。

Exchanger

  • 用于线程间交换数据,每两次执行Exchanger的exchange(V data)方法,则交换两次执行的数据并返回。可用于校对工作。

第九章 Java中的线程池

  • 线程池的3个好处
    1. 降低资源消耗:通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
    2. 提高响应速度:当任务到达时,任务可以不需要等到线程创建就能立即执行。
    3. 提高线程的可管理性:线程是稀缺资源,如果无限制地创建,不仅会消耗系统资源,还会降低系统的稳定性。使用线程池可以进行统一分配、调优和监控。
  • 当提交一个新任务到线程池时,线程池的流程:
    1. 如果当前运行的线程少于corePoolSize,则创建新线程来执行任务。
    2. 如果运行的线程等于或多于corePollSize,则将任务加入BlockingQueue。
    3. 如果无法将任务加入BlockingQueue(队列已满),则创建新的线程来处理任务。
    4. 如果创建新线程将导致当前运行的线程数超过maximumPoolSize,任务将被拒绝,并调用RejectedExecutionHandler.rejectedExecution()方法。

线程池的构造方法

  • ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, milliseconds, runnableTaskQueue, handler),其中:
    1. corePoolSize(线程池的基本大小):当提交一个任务到线程池时,线程池会创建一个线程来执行任务,即使其他空闲的基本线程能够执行新任务也会创建线程,知道需要执行的任务数大于线程池基本大小。如果调用了线程池的prestartAllCoreThreads()方法,线程池会提前创建并启动所有基本线程。
    2. runnableTaskQueue(任务队列):用于保存等待执行的任务的阻塞队列。可以选择ArratBlockingQueue, LinkedBlockingQueue, SynchronousQueue, PriorityBlockingQueue。
    3. maximumPoolSize(线程池最大数量):线程池允许创建的最大线程数。
    4. ThreadFactory:用于设置创建线程的工厂,可以通过线程工厂给每个创建出来的线程设置更有意义的名字。
    5. RejectedExecutionHandler(饱和策略):当队列和线程池都满了,说明线程池处于饱和状态,那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy,表示无法处理新任务时抛出异常。策略有下列几种:
      • AbortPolicy:直接抛出异常
      • CallerRunsPolicy:只用调用者所在线程来运行任务。
      • DiscardOldestPolicy:丢弃队列里最近的一个任务,并执行当前任务。
      • DiscardPolicy:不处理,丢弃掉。
      • 其他应用场景需要实现RejectedExecutionHandler接口自定义。
    6. keepAliveTime(线程活动保持时间):线程池的工作线程空闲后,保持存活的时间。如果任务多且执行时间短,可以调高存活时间提高线程利用率。
    7. TimeUnit(线程活动保持时间的单位)
  • 向线程池提交任务有两种方式:
    • execute(Runnable command):没有返回值
    • submit(Callable task):返回一个future类型的对象,通过这个对象判断任务是否执行成功,并通过其get()方法来获取返回值,该方法会阻塞当前线程知道任务完成。
  • 线程池的关闭有两种方法:
    • shutdown():将线程池的状态设置成SHUTDOWN状态,然后中断所有没有正在执行任务的线程。
    • shutdownNow():将线程池的状态设置成STOP,然后尝试停止所有的正在执行或暂停任务的线程,并返回等待执行任务的列表。
    • 只要调用了两种关闭方法的任一种,isShutdown()方法都会返回true。当且仅当所有任务都关闭,CIA表示线程池关闭成功,这是isTerminaed()方法才会返回true。

合理配置线程池(设N为CPU个数)

  • CPU密集型任务,应配置尽可能少的线程,如N+1。
  • IO密集型任务,应配置尽可能多的线程,如2N。
  • 优先级不同的任务可以考虑使用优先级队列priorityBlockingQueue来处理,但优先级低的任务可能永远不被执行。
  • 使用有界队列能增加系统的稳定性和预警性,避免队列越来越多撑满内存,导致系统不可用。

线程池的监控

  • 监控线程池的时候可以使用以下属性:
    • taskCount:线程池需要执行的任务数量。
    • completedTaskCount:线程池在运行过程中已完成的任务数量,小于或等于taskCount。
    • largestPoolSize:线程池里曾经创建过的最大线程数量。通过这个数据可以知道线程池是否曾经满过。
    • getPoolSize:线程池的线程数量。如果线程池不销毁的话,线程池里的线程不会自动销毁,所以这个大小只增不减。
    • getActiveCount:获取活动的线程数。
  • 可以通过继承线程池来自定义线程池,重写线程池的beforeExecute, afterExecute和terminated方法,也可以在任务执行前后和线程池关闭前执行一些代码来进行监控。例如,监控任务的平均执行时间、最大执行时间和最小执行时间等。这几个方法在线程池里都是空方法。

第十章 Executor框架

  • 工厂类Executors可创建3种类型的ThreadPoolExecutor:
    • FixedThreadPool:可重用固定线程数的线程池。new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue())
    • SingleThreadExecutor:使用单个worker线程的Executor。new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue())
    • CachedThreadPool:会根据需要创建新线程的线程池。new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue())
  • 工厂类Executors可创建2种类型的ScheduledThreadPoolExecutor:
    • ScheduledThreadPoolExecutor:包含若干个线程的ScheduledThreadPoolExecutor。
    • SingleThreadScheduledExecutor:只包含一个线程的ScheduledThreadPoolExecutor。

第十一章 Java并发编程实践

你可能感兴趣的:([转] 《Java并发编程的艺术》笔记)