《JAVA并发编程实践》随着多核处理器的普及,使用并发成为构建高性能应用程序的关键。Java 5以及6在开发并发程序中取得了显著的进步,提高了Java虚拟机的性能以及并发类的可伸缩性,并加入了丰富的新并发构建块。在《JAVA并发编程实践》中,这些便利工具的创造者不仅解释了它们究竟如何工作、如何使用,还阐释了创造它们的原因,及其背后的设计模式。

lgli/JAVA并发编程实践（中文）.pdf

lgrsnf/JAVA并发编程实践（中文）.pdf

zlib/no-category/戈茨/JAVA并发编程实践_11450792.pdf

Publishing House of Electronics Industry

China, People's Republic, China

lg2929605

{"isbns":["7121043165","9787121043161"],"last_page":403,"publisher":"电子工业出版社"}

Bookmarks: p1 (p1): 第1章 介绍
p2 (p1): 1.1 并发的（非常）简短历史
p3 (p3): 1.2 线程的优点
p4 (p5): 1.3 线程的风险
p5 (p9): 1.4 线程无处不在
p6 (p13): 第1部分 基础
p7 (p15): 第2章 线程安全
p8 (p17): 2.1 什么是线程安全性
p9 (p19): 2.2 原子性
p10 (p23): 2.3 锁
p11 (p27): 2.4 用锁来保护状态
p12 (p29): 2.5 活跃度与性能
p13 (p33): 第3章 共享对象
p14 (p33): 3.1 可见性
p15 (p39): 3.2 发布和逸出
p16 (p42): 3.3 线程封闭
p17 (p46): 3.4 不可变性
p18 (p49): 3.5 安全发布
p19 (p55): 第4章 组合对象
p20 (p55): 4.1 设计线程安全的类
p21 (p58): 4.2 实例限制
p22 (p62): 4.3 委托线程安全
p23 (p71): 4.4 向已有的线程安全类添加功能
p24 (p74): 4.5 同步策略的文档化
p25 (p79): 第5章 构建块
p26 (p79): 5.1 同步容器
p27 (p84): 5.2 并发容器
p28 (p87): 5.3 阻塞队列和生产者-消费者模式
p29 (p92): 5.4 阻塞和可中断的方法
p30 (p94): 5.5 Synchronizer
p31 (p101): 5.6 为计算结果建立高效、可伸缩的高速缓存
p32 (p111): 第2部分 构建并发应用程序
p33 (p113): 第6章 任务执行
p34 (p113): 6.1 在线程中执行任务
p35 (p117): 6.2 Executor框架
p36 (p123): 6.3 寻找可强化的并行性
p37 (p135): 第7章 取消和关闭
p38 (p135): 7.1 任务取消
p39 (p150): 7.2 停止基于线程的服务
p40 (p161): 7.3 处理反常的线程终止
p41 (p164): 7.4 JVM关闭
p42 (p167): 第8章 应用线程池
p43 (p167): 8.1 任务与执行策略间的隐性耦合
p44 (p170): 8.2 定制线程池的大小
p45 (p171): 8.3 配置ThreadPoolExecutor
p46 (p179): 8.4 扩展ThreadPoolExecutor
p47 (p181): 8.5 并行递归算法
p48 (p189): 第9章 GUI应用程序
p49 (p189): 9.1 为什么GUI是单线程化的
p50 (p192): 9.2 短期的GUI任务
p51 (p195): 9.3 耗时GUI任务
p52 (p198): 9.4 共享数据模型
p53 (p202): 9.5 其他形式的单线程子系统
p54 (p203): 第3部分 活跃度，性能和测试
p55 (p205): 第10章 避免活跃度危险
p56 (p205): 10.1 死锁
p57 (p215): 10.2 避免和诊断死锁
p58 (p218): 10.3 其他的活跃度危险
p59 (p221): 第11章 性能和可伸缩性
p60 (p221): 11.1 性能的思考
p61 (p225): 11.2 Amdahl定律
p62 (p229): 11.3 线程引入的开销
p63 (p232): 11.4 减少锁的竞争
p64 (p242): 11.5 示例：比较Map的性能
p65 (p243): 11.6 减少上下文切换的开销
p66 (p247): 第12章 测试并发程序
p67 (p248): 12.1 测试正确性
p68 (p260): 12.2 测试性能
p69 (p266): 12.3 避免性能测试的陷阱
p70 (p270): 12.4 测试方法补遗
p71 (p275): 第4部分 高级主题
p72 (p277): 第13章 显式锁
p73 (p277): 13.1 Lock和ReentrantLock
p74 (p282): 13.2 对性能的考量
p75 (p283): 13.3 公平性
p76 (p285): 13.4 在synchronized和ReentrantLock之间进行选择
p77 (p286): 13.5 读-写锁
p78 (p291): 第14章 构建自定义的同步工具
p79 (p291): 14.1 管理状态依赖性
p80 (p298): 14.2 使用条件队列
p81 (p306): 14.3 显式的Condition对象
p82 (p308): 14.4 剖析Synchronizer
p83 (p311): 14.5 AbstractQueuedSynchronizer
p84 (p314): 14.6 java.util.concurrent的Synchronizer类中的AQS
p85 (p319): 第15章 原子变量与非阻塞同步机制
p86 (p319): 15.1 锁的劣势
p87 (p321): 15.2 硬件对并发的支持
p88 (p324): 15.3 原子变量类
p89 (p329): 15.4 非阻塞算法
p90 (p337): 第16章 Java存储模型
p91 (p337): 16.1 什么是存储模型，要它何用
p92 (p344): 16.2 发布
p93 (p349): 16.3 初始化安全性
p94 (p353): 附录A 同步Annotation
p95 (p353): A.1 类Annotation
p96 (p353): A.2 域Annotation和方法Annotation
p97 (p355): 参考文献
p98 (p359): 索引
p99 (p6): 代码清单
p100 (p6): 清单1.1 非线程安全的序列生成器
p101 (p7): 清单1.2 线程安全的序列生成器
p102 (p18): 清单2.1 一个无状态的Servlet
p103 (p19): 清单2.2 Servlet计算请求数量而没有必要的同步（不要这样做）
p104 (p21): 清单2.3 惰性初始化中存在竞争条件（不要这样做）
p105 (p23): 清单2.4 Servlet使用AtomicLong统计请求数
p106 (p24): 清单2.5 没有正确原子化的Servlet试图缓存它的最新结果（不要这样做）
p107 (p26): 清单2.6 缓存了最新结果的servlet，但响应性令人无法接受（不要这样做）
p108 (p27): 清单2.7 如果内部锁不是可重入的，代码将死锁
p109 (p31): 清单2.8 缓存最新请求和结果的servlet
p110 (p34): 清单3.1 在没有同步的情况下共享变量（不要这样做）
p111 (p36): 清单3.2 非线程安全的可变整数访问器
p112 (p36): 清单3.3 线程安全的可变整数访问器
p113 (p39): 清单3.4 数绵羊
p114 (p40): 清单3.5 发布对象
p115 (p40): 清单3.6 允许内部可变的数据逸出（不要这样做）
p116 (p41): 清单3.7 隐式地允许this引用逸出（不要这样做）
p117 (p42): 清单3.8 使用工厂方法防止this引用在构造期间逸出
p118 (p44): 清单3.9 本地的基本类型和引用类型的变量的线程限制
p119 (p45): 清单3.10 使用Thread Local确保线程封闭性
p120 (p47): 清单3.11 构造于底层可变对象之上的不可变类
p121 (p49): 清单3.12 在不可变的容器中缓存数字和它的因数
p122 (p50): 清单3.13 使用到不可变容器对象的volatile类型引用，缓存最新的结果
p123 (p50): 清单3.14 在没有适当的同步的情况下就发布对象（不要这样做）
p124 (p51): 清单3.15 如果Holder没有被正确发布，它将处于失败的风险中
p125 (p56): 清单4.1 使用Java监视器模式的简单线程安全计数器
p126 (p59): 清单4.2 使用限制确保线程安全
p127 (p61): 清单4.3 私有锁保护状态
p128 (p63): 清单4.4 基于监视器的机动车追踪器实现
p129 (p64): 清单4.5 类似于java.awt.Point的可变Point
p130 (p64): 清单4.6 DelegatingVehicleTracker使用不可变的Point类
p131 (p65): 清单4.7 将线程安全委托到ConcurrentHashMap
p132 (p66): 清单4.8 返回location集的静态拷贝，而非“现场（live）”的
p133 (p66): 清单4.9 委托线程安全到多个底层的状态变量
p134 (p67): 清单4.10 NumberRange类没有完整地保护它的不变约束（不要这样做）
p135 (p69): 清单4.11 可变的线程安全Point类
p136 (p70): 清单4.12 安全发布底层状态的机动车追踪器
p137 (p72): 清单4.13 扩展的Vector包含一个“缺少即加入”方法
p138 (p72): 清单4.14 非线程安全的“缺少即加入”实现（不要这样做）
p139 (p73): 清单4.15 使用客户端加锁实现的“缺少即加入”
p140 (p74): 清单4.16 使用组合（composition）实现“缺少即加入”
p141 (p80): 清单5.1 操作Vector的复合操作可能导致混乱的结果
p142 (p81): 清单5.2 使用客户端加锁，对Vector进行复合操作
p143 (p81): 清单5.3 迭代中可能抛出的ArrayIndexOutOfBoundsException
p144 (p82): 清单5.4 使用客户端加锁进行迭代
p145 (p82): 清单5.5 用Iterator对List进行迭代
p146 (p84): 清单5.6 迭代隐藏在字符串的拼接中（不要这样做）
p147 (p87): 清单5.7 ConcurrentMap接口
p148 (p91): 清单5.8 桌面搜索应用程序中的生产者和消费者
p149 (p92): 清单5.9 开始桌面搜索
p150 (p94): 清单5.10 恢复中断状态，避免掩盖中断
p151 (p96): 清单5.11 在时序测试中，使用CountDownLatch来启动和停止线程
p152 (p97): 清单5.12 使用FutureTask预载稍后需要的数据
p153 (p98): 清单5.13 Throwable强制转换为RuntimeException
p154 (p100): 清单5.14 使用信号量来约束容器
p155 (p102): 清单5.15 在一个细胞的自动系统中用CyclicBarrier协调计算
p156 (p103): 清单5.16 尝试使用HashMap和同步来初始化缓存
p157 (p105): 清单5.17 用ConcurrentHashMap替换HashMap
p158 (p106): 清单5.18 用FutureTask记录包装器
p159 (p108): 清单5.19 Memoizer最终实现
p160 (p109): 清单5.20 使用Memoizer为因式分解的servlet缓存结果
p161 (p114): 清单6.1 顺序化的Web Server
p162 (p115): 清单6.2 Web Server为每个请求启动一个新的线程
p163 (p117): 清单6.3 Executor接口
p164 (p118): 清单6.4 使用线程池的Web server
p165 (p118): 清单6.5 为每个任务启动一个新线程的Executor
p166 (p119): 清单6.6 Executor在调用线程中同步地执行所有任务
p167 (p121): 清单6.7 ExecutorService中的生命周期方法
p168 (p122): 清单6.8 支持关闭操作的Web Server
p169 (p124): 清单6.9 Timer的混乱行为
p170 (p125): 清单6.10 顺序地渲染页面元素
p171 (p126): 清单6.11 Callable interface和Future interface
p172 (p126): 清单6.12 ThreadPoolExecutor中newTaskFor的默认实现
p173 (p128): 清单6.13 使用Future等待图像下载
p174 (p129): 清单6.14 ExecutorCompletionService使用的QueueingFuture类
p175 (p130): 清单6.15 使用CompletionService渲染可用的页面元素
p176 (p132): 清单6.16 在预定时间内获取广告信息
p177 (p134): 清单6.17 在预定时间内请求旅游报价
p178 (p137): 清单7.1 使用volatile域保存取消状态
p179 (p137): 清单7.2 生成素数的程序运行一秒钟
p180 (p139): 清单7.3 不可靠的取消把生产者置于阻塞的操作中（不要这样做）
p181 (p139): 清单7.4 线程的中断方法
p182 (p141): 清单7.5 通过使用中断进行取消
p183 (p143): 清单7.6 向调用者传递InterruptedException
p184 (p144): 清单7.7 不可取消的任务在退出前保存中断
p185 (p145): 清单7.8 在外部线程中安排中断（不要这样做）
p186 (p146): 清单7.9 在一个专门的线程中中断任务
p187 (p147): 清单7.10 通过Future来取消任务
p188 (p149): 清单7.11 在Thread中，通过覆写interrupt来封装非标准取消
p189 (p151): 清单7.12 用newTaskFor封装任务中非标准取消
p190 (p152): 清单7.13 不支持关闭的生产者-消费者日志服务
p191 (p153): 清单7.14 向日志服务添加不可靠的关闭支持
p192 (p154): 清单7.15 向LogWriter添加可靠的取消
p193 (p155): 清单7.16 使用ExecutorService的日志服务
p194 (p156): 清单7.17 使用致命药丸来关闭
p195 (p157): 清单7.18 IndexingService的生产者线程
p196 (p157): 清单7.19 IndexingService的消费者线程
p197 (p158): 清单7.20 使用私有Executor，将它的寿命限定于一次方法调用中
p198 (p159): 清单7.21 关闭之后，ExecutorService获取被取消的任务
p199 (p160): 清单7.22 使用TrackingExecutorService为后续执行来保存未完成的任务
p200 (p162): 清单7.23 典型线程池的工作者线程的构建
p201 (p163): 清单7.24 UncaughtExceptionHandler接口
p202 (p163): 清单7.25 UncaughtExceptionHandler将异常写入日志
p203 (p165): 清单7.26 注册关闭钩子来停止日志服务
p204 (p169): 清单8.1 在单线程化的Executor中死锁的任务（不要这样做）
p205 (p172): 清单8.2 ThreadPoolExecutor通用的构造函数
p206 (p175): 清单8.3 创建一个可变长的线程池，使用受限队列和“调用者运行”饱和策略。
p207 (p176): 清单8.4 使用Semaphore来遏制任务的提交
p208 (p176): 清单8.5 ThreadFactory接口
p209 (p177): 清单8.6 定制的线程工厂
p210 (p178): 清单8.7 自定义的线程基类
p211 (p179): 清单8.8 修改一个标准工厂方法创建的Executor
p212 (p180): 清单8.9 扩展线程池以提供日志和计时功能
p213 (p181): 清单8.10 把顺序执行转换为并行执行
p214 (p182): 清单8.11 把顺序递归转换为并行递归
p215 (p182): 清单8.12 等待并行运算的结果
p216 (p183): 清单8.13 类似于“搬箱子”谜题的抽象
p217 (p184): 清单8.14 谜题解决者框架的链节点
p218 (p185): 清单8.15 顺序化的谜题解决者
p219 (p186): 清单8.16 并发版的谜题解决者
p220 (p187): 清单8.17 ConcurrentPuzzleSolver使用可携带结果的闭锁
p221 (p188): 清单8.18 能够感知任务不存在的解决者
p222 (p193): 清单9.1 使用Executor实现的SwingUtilities
p223 (p194): 清单9.2 构建于SwingUtilities之上的Executor
p224 (p194): 清单9.3 简单的事件监听器
p225 (p196): 清单9.4 将耗时任务绑定到可视化组件
p226 (p196): 清单9.5 提供用户反馈的耗时任务
p227 (p197): 清单9.6 取消耗时任务
p228 (p199): 清单9.7 支持取消、完成和进度通知的后台任务类
p229 (p200): 清单9.8 在BackgroundTask中启动一个耗时的、可取消的任务
p230 (p207): 清单10.1 简单的锁顺序死锁（不要这样做）
p231 (p208): 清单10.2 动态加锁顺序产生的死锁（不要这样做）
p232 (p209): 清单10.3 制定锁的顺序来避免死锁
p233 (p210): 清单10.4 开始一个循环，它在典型条件下制定死锁
p234 (p212): 清单10.5 协作对象问的锁顺序死锁（不要这样做）
p235 (p214): 清单10.6 使用开放调用来避免协作对象之间的死锁
p236 (p217): 清单10.7 发生死锁后线程转储的部分信息
p237 (p227): 清单11.1 串行访问任务队列
p238 (p230): 清单11.2 徒劳的同步（不要这样做）
p239 (p231): 清单11.3 锁省略的候选程序
p240 (p233): 清单11.4 持有锁超过必要的时间
p241 (p234): 清单11.5 减少锁持续的时间
p242 (p236): 清单11.6 应当分拆锁的候选程序
p243 (p236): 清单11.7 使用分拆的锁重构ServerStatus
p244 (p238): 清单11.8 基于哈希的map中使用分离锁
p245 (p249): 清单12.1 利用Semaphore实现的有限缓存
p246 (p250): 清单12.2 BoundedBuffer的基本单元测试
p247 (p252): 清单12.3 测试阻塞与响应中断
p248 (p253): 清单12.4 适用于测试的中等品质的随机数生成器
p249 (p255): 清单12.5 BoundedBuffer的生产者-消费者测试程序
p250 (p256): 清单12.6 PutTakeTest中的生产者和消费者类
p251 (p258): 清单12.7 测试资源泄漏
p252 (p258): 清单12.8 用于测试ThreadPoolExecutor的线程工厂
p253 (p259): 清单12.9 验证线程池扩展的测试方法
p254 (p260): 清单12.10 使用Thread.yield产生更多的交替操作
p255 (p261): 清单12.11 基于关卡的计时器
p256 (p262): 清单12.12 使用基于关卡的计时器进行测试
p257 (p262): 清单12.13 TimedPutTakeTest的驱动程序
p258 (p277): 清单13.1 Lock接口
p259 (p278): 清单13.2 使用ReentrantLock保护对象状态
p260 (p280): 清单13.3 使用tryLock避免锁顺序死锁
p261 (p281): 清单13.4 具有预定时间的锁
p262 (p281): 清单13.5 可中断的锁获取请求
p263 (p286): 清单13.6 ReadWriteLock接口
p264 (p288): 清单13.7 用读写锁包装的Map
p265 (p292): 清单14.1 状态依赖的可阻塞行为的结构
p266 (p293): 清单14.2 有限缓存不同实现的基类
p267 (p294): 清单14.3 如果有限缓存不满足先验条件，会停滞不前
p268 (p294): 清单14.4 调用GrumpyBoundedBuffer的客户端逻辑
p269 (p296): 清单14.5 有限缓存使用了拙劣的阻塞
p270 (p298): 清单14.6 有限缓存使用条件队列
p271 (p301): 清单14.7 状态依赖方法的规范式
p272 (p304): 清单14.8 在BoundedBuffer.put中使用“依据条件通知”
p273 (p305): 清单14.9 使用wait和notifyAll实现可重关闭的阀门
p274 (p307): 清单14.10 Conditon接口
p275 (p309): 清单14.11 有限缓存使用显式的条件变量
p276 (p310): 清单14.12 使用lock实现的计数信号量
p277 (p312): 清单14.13 AQS中获取和释放操作的规范式
p278 (p313): 清单14.14 二元闭锁使用AbstractQueuedSynchronizer
p279 (p315): 清单14.15 非公平的ReentrantLock中tryAcquire的实现
p280 (p316): 清单14.16 Semaphore的tryAcquireShared和tryAcquireShared方法
p281 (p322): 清单15.1 模拟CAS操作
p282 (p323): 清单15.2 使用CAS实现的非阻塞计数器
p283 (p326): 清单15.3 使用CAS避免多元的不变约束
p284 (p327): 清单15.4 使用ReentrantLock实现随机数字生成器
p285 (p327): 清单15.5 使用AtomicInteger实现随机数字生成器
p286 (p331): 清单15.6 使用Treiber算法（Treiber,1986）的非阻塞栈
p287 (p334): 清单15.7 Michael-Scott非阻塞队列算法中的插入（Michael与Scott,1996）
p288 (p335): 清单15.8 在ConcurrentLinkedQueue中使用原子化的域更新器
p289 (p340): 清单16.1 没有充分同步的程序可以产生令人惊讶的结果（不要这样做）
p290 (p343): 清单16.2 FutureTask的内部类示范了如何“驾驭”同步
p291 (p345): 清单16.3 不安全的惰性初始化（不要这样做）
p292 (p347): 清单16.4 线程安全的惰性初始化
p293 (p347): 清单16.5 主动初始化
p294 (p348): 清单16.6 惰性初始化holder类技巧
p295 (p349): 清单16.7 检查锁反模式（不要这样做）
p296 (p350): 清单16.8 不可变对象的初始化安全性

封面
书名
版权
前言
第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 不可变对象的初始化安全性

Ben shu nei rong bao kuo ji ben de jie shao, Xian cheng an quan, Gong xiang dui xiang, Zu he dui xiang, Gou jian kuai, Ren wu zhi xing, Qu xiao he guan bi, Ying yong xian cheng chi deng gong shi liu zhang

本书内容包括:基本的介绍, 线程安全, 共享对象, 组合对象, 构建块, 任务执行, 取消和关闭, 应用线程池, 避免活跃度危险, 性能和可伸缩性, 测试并发程序等共十六章

2021-01-30