JAVA并发编程实践(中文)

内容简介

JAVA并发编程实践(中文)

目录

  • 封面
    • 书名
      • 版权
        • 前言
          • 第1章 介绍
            • 1.1 并发的(非常)简短历史
              • 1.2 线程的优点
                • 1.3 线程的风险
                  • 1.4 线程无处不在
                    • 第1部分 基础
                      • 第2章 线程安全
                        • 2.1 什么是线程安全性
                          • 2.2 原子性
                            • 2.3 锁
                              • 2.4 用锁来保护状态
                                • 2.5 活跃度与性能
                                  • 第3章 共享对象
                                    • 3.1 可见性
                                      • 3.2 发布和逸出
                                        • 3.3 线程封闭
                                          • 3.4 不可变性
                                            • 3.5 安全发布
                                              • 第4章 组合对象
                                                • 4.1 设计线程安全的类
                                                  • 4.2 实例限制
                                                    • 4.3 委托线程安全
                                                      • 4.4 向已有的线程安全类添加功能
                                                        • 4.5 同步策略的文档化
                                                          • 第5章 构建块
                                                            • 5.1 同步容器
                                                              • 5.2 并发容器
                                                                • 5.3 阻塞队列和生产者-消费者模式
                                                                  • 5.4 阻塞和可中断的方法
                                                                    • 5.5 Synchronizer
                                                                      • 5.6 为计算结果建立高效、可伸缩的高速缓存
                                                                        • 第2部分 构建并发应用程序
                                                                          • 第6章 任务执行
                                                                            • 6.1 在线程中执行任务
                                                                              • 6.2 Executor框架
                                                                                • 6.3 寻找可强化的并行性
                                                                                  • 第7章 取消和关闭
                                                                                    • 7.1 任务取消
                                                                                      • 7.2 停止基于线程的服务
                                                                                        • 7.3 处理反常的线程终止
                                                                                          • 7.4 JVM关闭
                                                                                            • 第8章 应用线程池
                                                                                              • 8.1 任务与执行策略间的隐性耦合
                                                                                                • 8.2 定制线程池的大小
                                                                                                  • 8.3 配置ThreadPoolExecutor
                                                                                                    • 8.4 扩展ThreadPoolExecutor
                                                                                                      • 8.5 并行递归算法
                                                                                                        • 第9章 GUI应用程序
                                                                                                          • 9.1 为什么GUI是单线程化的
                                                                                                            • 9.2 短期的GUI任务
                                                                                                              • 9.3 耗时GUI任务
                                                                                                                • 9.4 共享数据模型
                                                                                                                  • 9.5 其他形式的单线程子系统
                                                                                                                    • 第3部分 活跃度,性能和测试
                                                                                                                      • 第10章 避免活跃度危险
                                                                                                                        • 10.1 死锁
                                                                                                                          • 10.2 避免和诊断死锁
                                                                                                                            • 10.3 其他的活跃度危险
                                                                                                                              • 第11章 性能和可伸缩性
                                                                                                                                • 11.1 性能的思考
                                                                                                                                  • 11.2 Amdahl定律
                                                                                                                                    • 11.3 线程引入的开销
                                                                                                                                      • 11.4 减少锁的竞争
                                                                                                                                        • 11.5 示例:比较Map的性能
                                                                                                                                          • 11.6 减少上下文切换的开销
                                                                                                                                            • 第12章 测试并发程序
                                                                                                                                              • 12.1 测试正确性
                                                                                                                                                • 12.2 测试性能
                                                                                                                                                  • 12.3 避免性能测试的陷阱
                                                                                                                                                    • 12.4 测试方法补遗
                                                                                                                                                      • 第4部分 高级主题
                                                                                                                                                        • 第13章 显式锁
                                                                                                                                                          • 13.1 Lock和ReentrantLock
                                                                                                                                                            • 13.2 对性能的考量
                                                                                                                                                              • 13.3 公平性
                                                                                                                                                                • 13.4 在synchronized和ReentrantLock之间进行选择
                                                                                                                                                                  • 13.5 读-写锁
                                                                                                                                                                    • 第14章 构建自定义的同步工具
                                                                                                                                                                      • 14.1 管理状态依赖性
                                                                                                                                                                        • 14.2 使用条件队列
                                                                                                                                                                          • 14.3 显式的Condition对象
                                                                                                                                                                            • 14.4 剖析Synchronizer
                                                                                                                                                                              • 14.5 AbstractQueuedSynchronizer
                                                                                                                                                                                • 14.6 java.util.concurrent的Synchronizer类中的AQS
                                                                                                                                                                                  • 第15章 原子变量与非阻塞同步机制
                                                                                                                                                                                    • 15.1 锁的劣势
                                                                                                                                                                                      • 15.2 硬件对并发的支持
                                                                                                                                                                                        • 15.3 原子变量类
                                                                                                                                                                                          • 15.4 非阻塞算法
                                                                                                                                                                                            • 第16章 Java存储模型
                                                                                                                                                                                              • 16.1 什么是存储模型,要它何用
                                                                                                                                                                                                • 16.2 发布
                                                                                                                                                                                                  • 16.3 初始化安全性
                                                                                                                                                                                                    • 附录A 同步Annotation
                                                                                                                                                                                                      • A.1 类Annotation
                                                                                                                                                                                                        • A.2 域Annotation和方法Annotation
                                                                                                                                                                                                          • 参考文献
                                                                                                                                                                                                            • 索引
                                                                                                                                                                                                              • 代码清单
                                                                                                                                                                                                                • 清单1.1 非线程安全的序列生成器
                                                                                                                                                                                                                  • 清单1.2 线程安全的序列生成器
                                                                                                                                                                                                                    • 清单2.1 一个无状态的Servlet
                                                                                                                                                                                                                      • 清单2.2 Servlet计算请求数量而没有必要的同步(不要这样做)
                                                                                                                                                                                                                        • 清单2.3 惰性初始化中存在竞争条件(不要这样做)
                                                                                                                                                                                                                          • 清单2.4 Servlet使用AtomicLong统计请求数
                                                                                                                                                                                                                            • 清单2.5 没有正确原子化的Servlet试图缓存它的最新结果(不要这样做)
                                                                                                                                                                                                                              • 清单2.6 缓存了最新结果的servlet,但响应性令人无法接受(不要这样做)
                                                                                                                                                                                                                                • 清单2.7 如果内部锁不是可重入的,代码将死锁
                                                                                                                                                                                                                                  • 清单2.8 缓存最新请求和结果的servlet
                                                                                                                                                                                                                                    • 清单3.1 在没有同步的情况下共享变量(不要这样做)
                                                                                                                                                                                                                                      • 清单3.2 非线程安全的可变整数访问器
                                                                                                                                                                                                                                        • 清单3.3 线程安全的可变整数访问器
                                                                                                                                                                                                                                          • 清单3.4 数绵羊
                                                                                                                                                                                                                                            • 清单3.5 发布对象
                                                                                                                                                                                                                                              • 清单3.6 允许内部可变的数据逸出(不要这样做)
                                                                                                                                                                                                                                                • 清单3.7 隐式地允许this引用逸出(不要这样做)
                                                                                                                                                                                                                                                  • 清单3.8 使用工厂方法防止this引用在构造期间逸出
                                                                                                                                                                                                                                                    • 清单3.9 本地的基本类型和引用类型的变量的线程限制
                                                                                                                                                                                                                                                      • 清单3.10 使用Thread Local确保线程封闭性
                                                                                                                                                                                                                                                        • 清单3.11 构造于底层可变对象之上的不可变类
                                                                                                                                                                                                                                                          • 清单3.12 在不可变的容器中缓存数字和它的因数
                                                                                                                                                                                                                                                            • 清单3.13 使用到不可变容器对象的volatile类型引用,缓存最新的结果
                                                                                                                                                                                                                                                              • 清单3.14 在没有适当的同步的情况下就发布对象(不要这样做)
                                                                                                                                                                                                                                                                • 清单3.15 如果Holder没有被正确发布,它将处于失败的风险中
                                                                                                                                                                                                                                                                  • 清单4.1 使用Java监视器模式的简单线程安全计数器
                                                                                                                                                                                                                                                                    • 清单4.2 使用限制确保线程安全
                                                                                                                                                                                                                                                                      • 清单4.3 私有锁保护状态
                                                                                                                                                                                                                                                                        • 清单4.4 基于监视器的机动车追踪器实现
                                                                                                                                                                                                                                                                          • 清单4.5 类似于java.awt.Point的可变Point
                                                                                                                                                                                                                                                                            • 清单4.6 DelegatingVehicleTracker使用不可变的Point类
                                                                                                                                                                                                                                                                              • 清单4.7 将线程安全委托到ConcurrentHashMap
                                                                                                                                                                                                                                                                                • 清单4.8 返回location集的静态拷贝,而非“现场(live)”的
                                                                                                                                                                                                                                                                                  • 清单4.9 委托线程安全到多个底层的状态变量
                                                                                                                                                                                                                                                                                    • 清单4.10 NumberRange类没有完整地保护它的不变约束(不要这样做)
                                                                                                                                                                                                                                                                                      • 清单4.11 可变的线程安全Point类
                                                                                                                                                                                                                                                                                        • 清单4.12 安全发布底层状态的机动车追踪器
                                                                                                                                                                                                                                                                                          • 清单4.13 扩展的Vector包含一个“缺少即加入”方法
                                                                                                                                                                                                                                                                                            • 清单4.14 非线程安全的“缺少即加入”实现(不要这样做)
                                                                                                                                                                                                                                                                                              • 清单4.15 使用客户端加锁实现的“缺少即加入”
                                                                                                                                                                                                                                                                                                • 清单4.16 使用组合(composition)实现“缺少即加入”
                                                                                                                                                                                                                                                                                                  • 清单5.1 操作Vector的复合操作可能导致混乱的结果
                                                                                                                                                                                                                                                                                                    • 清单5.2 使用客户端加锁,对Vector进行复合操作
                                                                                                                                                                                                                                                                                                      • 清单5.3 迭代中可能抛出的ArrayIndexOutOfBoundsException
                                                                                                                                                                                                                                                                                                        • 清单5.4 使用客户端加锁进行迭代
                                                                                                                                                                                                                                                                                                          • 清单5.5 用Iterator对List进行迭代
                                                                                                                                                                                                                                                                                                            • 清单5.6 迭代隐藏在字符串的拼接中(不要这样做)
                                                                                                                                                                                                                                                                                                              • 清单5.7 ConcurrentMap接口
                                                                                                                                                                                                                                                                                                                • 清单5.8 桌面搜索应用程序中的生产者和消费者
                                                                                                                                                                                                                                                                                                                  • 清单5.9 开始桌面搜索
                                                                                                                                                                                                                                                                                                                    • 清单5.10 恢复中断状态,避免掩盖中断
                                                                                                                                                                                                                                                                                                                      • 清单5.11 在时序测试中,使用CountDownLatch来启动和停止线程
                                                                                                                                                                                                                                                                                                                        • 清单5.12 使用FutureTask预载稍后需要的数据
                                                                                                                                                                                                                                                                                                                          • 清单5.13 Throwable强制转换为RuntimeException
                                                                                                                                                                                                                                                                                                                            • 清单5.14 使用信号量来约束容器
                                                                                                                                                                                                                                                                                                                              • 清单5.15 在一个细胞的自动系统中用CyclicBarrier协调计算
                                                                                                                                                                                                                                                                                                                                • 清单5.16 尝试使用HashMap和同步来初始化缓存
                                                                                                                                                                                                                                                                                                                                  • 清单5.17 用ConcurrentHashMap替换HashMap
                                                                                                                                                                                                                                                                                                                                    • 清单5.18 用FutureTask记录包装器
                                                                                                                                                                                                                                                                                                                                      • 清单5.19 Memoizer最终实现
                                                                                                                                                                                                                                                                                                                                        • 清单5.20 使用Memoizer为因式分解的servlet缓存结果
                                                                                                                                                                                                                                                                                                                                          • 清单6.1 顺序化的Web Server
                                                                                                                                                                                                                                                                                                                                            • 清单6.2 Web Server为每个请求启动一个新的线程
                                                                                                                                                                                                                                                                                                                                              • 清单6.3 Executor接口
                                                                                                                                                                                                                                                                                                                                                • 清单6.4 使用线程池的Web server
                                                                                                                                                                                                                                                                                                                                                  • 清单6.5 为每个任务启动一个新线程的Executor
                                                                                                                                                                                                                                                                                                                                                    • 清单6.6 Executor在调用线程中同步地执行所有任务
                                                                                                                                                                                                                                                                                                                                                      • 清单6.7 ExecutorService中的生命周期方法
                                                                                                                                                                                                                                                                                                                                                        • 清单6.8 支持关闭操作的Web Server
                                                                                                                                                                                                                                                                                                                                                          • 清单6.9 Timer的混乱行为
                                                                                                                                                                                                                                                                                                                                                            • 清单6.10 顺序地渲染页面元素
                                                                                                                                                                                                                                                                                                                                                              • 清单6.11 Callable interface和Future interface
                                                                                                                                                                                                                                                                                                                                                                • 清单6.12 ThreadPoolExecutor中newTaskFor的默认实现
                                                                                                                                                                                                                                                                                                                                                                  • 清单6.13 使用Future等待图像下载
                                                                                                                                                                                                                                                                                                                                                                    • 清单6.14 ExecutorCompletionService使用的QueueingFuture类
                                                                                                                                                                                                                                                                                                                                                                      • 清单6.15 使用CompletionService渲染可用的页面元素
                                                                                                                                                                                                                                                                                                                                                                        • 清单6.16 在预定时间内获取广告信息
                                                                                                                                                                                                                                                                                                                                                                          • 清单6.17 在预定时间内请求旅游报价
                                                                                                                                                                                                                                                                                                                                                                            • 清单7.1 使用volatile域保存取消状态
                                                                                                                                                                                                                                                                                                                                                                              • 清单7.2 生成素数的程序运行一秒钟
                                                                                                                                                                                                                                                                                                                                                                                • 清单7.3 不可靠的取消把生产者置于阻塞的操作中(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                  • 清单7.4 线程的中断方法
                                                                                                                                                                                                                                                                                                                                                                                    • 清单7.5 通过使用中断进行取消
                                                                                                                                                                                                                                                                                                                                                                                      • 清单7.6 向调用者传递InterruptedException
                                                                                                                                                                                                                                                                                                                                                                                        • 清单7.7 不可取消的任务在退出前保存中断
                                                                                                                                                                                                                                                                                                                                                                                          • 清单7.8 在外部线程中安排中断(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                            • 清单7.9 在一个专门的线程中中断任务
                                                                                                                                                                                                                                                                                                                                                                                              • 清单7.10 通过Future来取消任务
                                                                                                                                                                                                                                                                                                                                                                                                • 清单7.11 在Thread中,通过覆写interrupt来封装非标准取消
                                                                                                                                                                                                                                                                                                                                                                                                  • 清单7.12 用newTaskFor封装任务中非标准取消
                                                                                                                                                                                                                                                                                                                                                                                                    • 清单7.13 不支持关闭的生产者-消费者日志服务
                                                                                                                                                                                                                                                                                                                                                                                                      • 清单7.14 向日志服务添加不可靠的关闭支持
                                                                                                                                                                                                                                                                                                                                                                                                        • 清单7.15 向LogWriter添加可靠的取消
                                                                                                                                                                                                                                                                                                                                                                                                          • 清单7.16 使用ExecutorService的日志服务
                                                                                                                                                                                                                                                                                                                                                                                                            • 清单7.17 使用致命药丸来关闭
                                                                                                                                                                                                                                                                                                                                                                                                              • 清单7.18 IndexingService的生产者线程
                                                                                                                                                                                                                                                                                                                                                                                                                • 清单7.19 IndexingService的消费者线程
                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单7.20 使用私有Executor,将它的寿命限定于一次方法调用中
                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单7.21 关闭之后,ExecutorService获取被取消的任务
                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单7.22 使用TrackingExecutorService为后续执行来保存未完成的任务
                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单7.23 典型线程池的工作者线程的构建
                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单7.24 UncaughtExceptionHandler接口
                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单7.25 UncaughtExceptionHandler将异常写入日志
                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单7.26 注册关闭钩子来停止日志服务
                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单8.1 在单线程化的Executor中死锁的任务(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单8.2 ThreadPoolExecutor通用的构造函数
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单8.3 创建一个可变长的线程池,使用受限队列和“调用者运行”饱和策略。
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单8.4 使用Semaphore来遏制任务的提交
                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单8.5 ThreadFactory接口
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单8.6 定制的线程工厂
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单8.7 自定义的线程基类
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单8.8 修改一个标准工厂方法创建的Executor
                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单8.9 扩展线程池以提供日志和计时功能
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单8.10 把顺序执行转换为并行执行
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单8.11 把顺序递归转换为并行递归
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单8.12 等待并行运算的结果
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单8.13 类似于“搬箱子”谜题的抽象
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单8.14 谜题解决者框架的链节点
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单8.15 顺序化的谜题解决者
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单8.16 并发版的谜题解决者
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单8.17 ConcurrentPuzzleSolver使用可携带结果的闭锁
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单8.18 能够感知任务不存在的解决者
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单9.1 使用Executor实现的SwingUtilities
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单9.2 构建于SwingUtilities之上的Executor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单9.3 简单的事件监听器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单9.4 将耗时任务绑定到可视化组件
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单9.5 提供用户反馈的耗时任务
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单9.6 取消耗时任务
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单9.7 支持取消、完成和进度通知的后台任务类
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单9.8 在BackgroundTask中启动一个耗时的、可取消的任务
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单10.1 简单的锁顺序死锁(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单10.2 动态加锁顺序产生的死锁(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单10.3 制定锁的顺序来避免死锁
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单10.4 开始一个循环,它在典型条件下制定死锁
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单10.5 协作对象问的锁顺序死锁(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单10.6 使用开放调用来避免协作对象之间的死锁
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单10.7 发生死锁后线程转储的部分信息
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单11.1 串行访问任务队列
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单11.2 徒劳的同步(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单11.3 锁省略的候选程序
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单11.4 持有锁超过必要的时间
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单11.5 减少锁持续的时间
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单11.6 应当分拆锁的候选程序
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单11.7 使用分拆的锁重构ServerStatus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单11.8 基于哈希的map中使用分离锁
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单12.1 利用Semaphore实现的有限缓存
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单12.2 BoundedBuffer的基本单元测试
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单12.3 测试阻塞与响应中断
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单12.4 适用于测试的中等品质的随机数生成器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单12.5 BoundedBuffer的生产者-消费者测试程序
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单12.6 PutTakeTest中的生产者和消费者类
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单12.7 测试资源泄漏
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单12.8 用于测试ThreadPoolExecutor的线程工厂
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单12.9 验证线程池扩展的测试方法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单12.10 使用Thread.yield产生更多的交替操作
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单12.11 基于关卡的计时器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单12.12 使用基于关卡的计时器进行测试
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单12.13 TimedPutTakeTest的驱动程序
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单13.1 Lock接口
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单13.2 使用ReentrantLock保护对象状态
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单13.3 使用tryLock避免锁顺序死锁
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单13.4 具有预定时间的锁
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单13.5 可中断的锁获取请求
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单13.6 ReadWriteLock接口
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单13.7 用读写锁包装的Map
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单14.1 状态依赖的可阻塞行为的结构
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单14.2 有限缓存不同实现的基类
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单14.3 如果有限缓存不满足先验条件,会停滞不前
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单14.4 调用GrumpyBoundedBuffer的客户端逻辑
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单14.5 有限缓存使用了拙劣的阻塞
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单14.6 有限缓存使用条件队列
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单14.7 状态依赖方法的规范式
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单14.8 在BoundedBuffer.put中使用“依据条件通知”
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单14.9 使用wait和notifyAll实现可重关闭的阀门
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单14.10 Conditon接口
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单14.11 有限缓存使用显式的条件变量
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单14.12 使用lock实现的计数信号量
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单14.13 AQS中获取和释放操作的规范式
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单14.14 二元闭锁使用AbstractQueuedSynchronizer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单14.15 非公平的ReentrantLock中tryAcquire的实现
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单14.16 Semaphore的tryAcquireShared和tryAcquireShared方法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单15.1 模拟CAS操作
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单15.2 使用CAS实现的非阻塞计数器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单15.3 使用CAS避免多元的不变约束
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单15.4 使用ReentrantLock实现随机数字生成器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单15.5 使用AtomicInteger实现随机数字生成器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单15.6 使用Treiber算法(Treiber,1986)的非阻塞栈
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单15.7 Michael-Scott非阻塞队列算法中的插入(Michael与Scott,1996)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单15.8 在ConcurrentLinkedQueue中使用原子化的域更新器
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 清单16.1 没有充分同步的程序可以产生令人惊讶的结果(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 清单16.2 FutureTask的内部类示范了如何“驾驭”同步
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 清单16.3 不安全的惰性初始化(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 清单16.4 线程安全的惰性初始化
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 清单16.5 主动初始化
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 清单16.6 惰性初始化holder类技巧
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 清单16.7 检查锁反模式(不要这样做)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 清单16.8 不可变对象的初始化安全性