9787121382451
9787121379727

书名: Java多线程编程实战指南-设计模式篇(2版)

作者: 黄文海

定价: 69.00元

ISBN编号: 9787121382451

开本: 16开

是否是套装: 否

出版社名称: 电子工业出版社



  随着CPU多核时代的到来，多线程编程在充分利用计算资源、提高软件服务质量方面扮演了越来越重要的角色。解决多线程编程中频繁出现的普遍问题可以借鉴设计模式所提供的现成解决方案。然而，多线程编程相关的设计模式图书多采用C++作为描述语言，且书中所举的例子多与应用开发人员的实际工作相去甚远。本书采用Java语言和UML为描述语言，并结合作者多年工作经历及相关实践经验，介绍了多线程环境下常用设计模式的来龙去脉：各个设计模式是什么样的、典型的实际应用场景、实际应用时需要注意的事项及各个设计模式的可复用代码实现。本书2版除更正了1版中的错误外，还新增了JDK 8、JDK 9中与多线程设计模式相关的内容，并对代码进行了重构和重新排版，使代码部分重点更突出、更易于阅读，以及提高了插图的清晰度。本书适合有一定Java多线程编程基础、经验的读者阅读。


1章 Java多线程编程实战基础 1
1.1 无处不在的线程 1
1.2 线程的创建与运行 3
1.3 线程的状态与上下文切换 5
1.4 对线程的监视 8
1.5 原子性、内存可见性和重排序——重新认识synchronized
和volatile 11
1.6 多线程编程的优势和风险 13
1.7 多线程编程常用术语 14
2章 设计模式简介 19
2.1 设计模式及其作用 19
2.2 多线程设计模式简介 22
2.3 设计模式的描述 23
3章 Immutable Object（不可变对象）模式 25
3.1 Immutable Object模式简介 25
3.2 Immutable Object模式的架构 27
3.3 Immutable Object模式实战案例解析 29
3.4 Immutable Object模式的评价与实现考量 33
3.4.1 适用场景 33
3.4.2 对垃圾回收（Garbage Collection）的影响 34
3.4.3 使用等效或者近似的不可变对象 35
3.4.4 防御性复制 35
3.5 Immutable Object模式的可复用实现代码 35
3.6 Java标准库实例 35
3.7 相关模式 37
3.7.1 Thread Specific Storage模式（10章） 37
3.7.2 Serial Thread Confinement模式（11章） 37
3.8 参考资源 38
4章 Guarded Suspension（保护性暂挂）模式 39
4.1 Guarded Suspension模式简介 39
4.2 Guarded Suspension模式的架构 39
4.3 Guarded Suspension模式实战案例解析 43
4.4 Guarded Suspension模式的评价与实现考量 50
4.4.1 内存可见性和锁泄漏（Lock Leak） 51
4.4.2 线程被过早地唤醒 52
4.4.3 嵌套监视器锁死 53
4.5 Guarded Suspension模式的可复用实现代码 56
4.6 Java标准库实例 56
4.7 相关模式 56
4.7.1 Promise模式（6章） 57
4.7.2 Producer-Consumer模式（7章） 57
4.8 参考资源 57
5章 Two-phase Termination（两阶段终止）模式 58
5.1 Two-phase Termination模式简介 58
5.2 Two-phase Termination模式的架构 59
5.3 Two-phase Termination模式实战案例解析 61
5.4 Two-phase Termination模式的评价与实现考量 70
5.4.1 线程停止标志 71
5.4.2 生产者/消费者问题中的线程停止 71
5.4.3 隐藏而非暴可停止线程 73
5.5 Two-phase Termination模式的可复用实现代码 73
5.6 Java标准库实例 73
5.7 相关模式 74
5.7.1 Producer-Consumer模式（7章） 74
5.7.2 Master-Slave模式（12章） 74
5.8 参考资源 74
6章 Promise（承诺）模式 75
6.1 Promise模式简介 75
6.2 Promise模式的架构 75
6.3 Promise模式实战案例解析 78
6.4 Promise模式的评价与实现考量 81
6.4.1 异步方法的异常处理 82
6.4.2 轮询 82
6.4.3 异步任务的执行 83
6.5 Promise模式的可复用实现代码 84
6.6 Java标准库实例 85
6.7 相关模式 85
6.7.1 Guarded Suspension模式（4章） 85
6.7.2 Active Object模式（8章） 86
6.7.3 Master-Slave模式（12章） 86
6.7.4 Factory Method（工厂方法）模式 86
6.8 参考资源 86
7章 Producer-Consumer（生产者/消费者）模式 87
7.1 Producer-Consumer模式简介 87
7.2 Producer-Consumer模式的架构 87
7.3 Producer-Consumer模式实战案例解析 90
7.4 Producer-Consumer模式的评价与实现考量 93
7.4.1 产品的粒度 94
7.4.2 通道积压 94
7.4.3 非阻塞式反压与Reactive Streams规范 96
7.4.4 工作窃取算法 97
7.4.5 线程的停止 101
7.4.6 高性能、高可靠性的Producer-Consumer模式实现 101
7.5 Producer-Consumer模式的可复用实现代码 102
7.6 Java标准库实例 102
7.7 相关模式 102
7.7.1 Guarded Suspension模式（4章） 102
7.7.2 Thread Pool模式（9章） 103
7.8 参考资源 103
8章 Active Object（主动对象）模式 104
8.1 Active Object模式简介 104
8.2 Active Object模式的架构 105
8.3 Active Object模式实战案例解析 108
8.4 Active Object模式的评价与实现考量 115
.。。。




书名: Java并发实现原理-JDK源码剖析

作者: 余春龙

定价: 89.00元

ISBN编号: 9787121379727

开本: 16开

是否是套装: 否

出版社名称: 电子工业出版社


本书全面而系统地剖析了Java Concurrent包中的每一个部分，对并发的实现原理进行了深刻的探讨。全书分为8章，1章从*基础的多线程知识讲起，理清多线程中容易误解的知识点，探究背后的原理，包括内存重排序、happen-before、内存屏障等；2~8章，从简单到复杂，逐个剖析Concurrent包的每个部分，包括原子类、锁、同步工具类、并发容器、线程池、ForkJoinPool、CompletableFuture共7个部分。本书遵循层层递进的逻辑，后一章建立在前一章的知识点基础之上，建议读者由浅入深，逐步深入阅读。本书适合有一定Java开发经验的工程师、架构师阅读。通过本书，读者可以对多线程编程形成一个“深刻而直观”的认识，而不是再仅仅停留在概念和理论层面。




1章 多线程基础 / 1
1.1 线程的优雅关闭 / 1
1.1.1 s与destory函数 / 1
1.1.2 守护线程 / 1
1.1.3 设置关闭的标志位 / 2
1.2 InterruptedEception与interrupt()函数 / 3
1.2.1 什么情况下会抛出Interrupted异常 / 3
1.2.2 轻量级阻塞与重量级阻塞 / 4
1.2.3 t.isInterrupted()与Thread.interrupted()的区别 / 5
1.3 synchronized关键字 / 5
1.3.1 锁的对象是什么 / 5
1.3.2 锁的本质是什么 / 6
1.3.3 synchronized实现原理 / 7
1.4 wait与tify / 7
1.4.1 生产者?消费者模型 / 7
1.4.2 为什么必须和synchornized一起使用 / 8
1.4.3 为什么wait()的时候必须释放锁 / 9
1.4.4 wait()与tify()的问题 / 10
1.5 volatile关键字 / 11
1.5.1 64位写入的原子性（Half Write） / 11
1.5.2 内存可见性 / 11
1.5.3 重排序：DCL问题 / 12
1.6 JMM与happen-before / 13
1.6.1 为什么会存在“内存可见性”问题 / 13
1.6.2 重排序与内存可见性的关系 / 15
1.6.3 as-if-serial语义 / 16
1.6.4 happen-before是什么 / 17
1.6.5 happen-before的传递性 / 18
1.6.6 C++中的volatile关键字 / 19
1.6.7 JSR-133对volatile语义的增强 / 20
1.7 内存屏障 / 20
1.7.1 Linu中的内存屏障 / 21
1.7.2 JDK中的内存屏障 / 23
1.7.3 volatile实现原理 / 24
1.8 final关键字 / 25
1.8.1 构造函数溢出问题 / 25
1.8.2 final的happen-before语义 / 26
1.8.3 happen-before规则总结 / 26
1.9 综合应用：无锁编程 / 27
1.9.1 一写一读的无锁队列：内存屏障 / 27
1.9.2 一写多读的无锁队列：volatile关键字 / 27
1.9.3 多写多读的无锁队列：CAS / 28
1.9.4 无锁栈 / 28
1.9.5 无锁链表 / 28
2章 Atomic类 / 29
2.1 AtomicInteger和AtomicLong / 29
2.1.1 悲观锁与乐观锁 / 31
2.1.2 Unsafe 的CAS详解 / 31
2.1.3 自旋与阻塞 / 32
2.2 AtomicBoolean和AtomicReference / 33
2.2.1 为什么需要AtomicBoolean / 33
2.2.2 如何支持boolean和double类型 / 33
2.3 AtomicStampedReference和AtomicMarkable Reference / 34
2.3.1 ABA问题与解决办法 / 34
2.3.2 为什么没有AtomicStampedInteger或AtomictStampedLong / 35
2.3.3 AtomicMarkableReference / 36
2.4 AtomicIntegerFieldUpdater、AtomicLongFieldUpdater和AtomicReferenceField Updater / 37
2.4.1 为什么需要AtomicXXXFieldUpdater / 37
2.4.2 限制条件 / 38
2.5 AtomicIntegerArray、AtomicLongArray和
AtomicReferenceArray / 38
2.5.1 使用方式 / 38
2.5.2 实现原理 / 39
2.6 Striped64与LongAdder / 40
2.6.1 LongAdder原理 / 40
2.6.2 *终一致性 / 41
2.6.3 伪共享与缓存行填充 / 42
2.6.4 LongAdder核心实现 / 43
2.6.5 LongAccumulator / 47
2.6.6 DoubleAdder与DoubleAccumulator / 47
3章 Lock与Condition / 49
3.1 互斥锁 / 49
3.1.1 锁的可重入性 / 49
3.1.2 类继承层次 / 49
3.1.3 锁的公平性vs.非公平性 / 51
3.1.4 锁实现的基本原理 / 51
3.1.5 公平与非公平的lock()实现差异 / 53
3.1.6 阻塞队列与唤醒机制 / 55
3.1.7 unlock()实现分析 / 58
3.1.8 lockInterruptibly()实现分析 / 59
3.1.9 tryLock()实现分析 / 60
3.2 读写锁 / 60
3.2.1 类继承层次 / 60
3.2.2 读写锁实现的基本原理 / 61
3.2.3 AQS的两对模板方法 / 62
3.2.4 WriteLock公平vs.非公平实现 / 65
3.2.5 ReadLock公平vs.非公平实现 / 67
3.3 Condition / 68
3.3.1 Condition与Lock的关系 / 68
3.3.2 Condition的使用场景 / 69
3.3.3 Condition实现原理 / 71
3.3.4 await()实现分析 / 72
3.3.5 awaitUninterruptibly()实现分析 / 73
3.3.6 tify()实现分析 / 74
3.4 StampedLock / 75
3.4.1 为什么引入StampedLock / 75
3.4.2 使用场景 / 75
3.4.3 “乐观读”的实现原理 / 77
3.4.4 悲观读/写：“阻塞”与“自旋”策略实现差异 / 78
4章 同步工具类 / 83
4.1 Semaphore / 83
4.2 CountDownLatch / 84
4.2.1 CountDownLatch使用场景 / 84
4.2.2 await()实现分析 / 85
4.2.3 countDown()实现分析 / 85
4.3 CyclicBarrier / 86
4.3.1 CyclicBarrier使用场景 / 86
4.3.2 CyclicBarrier实现原理 / 87
4.4 Echanger / 90
4.4.1 Echanger使用场景 / 90
4.4.2 Echanger 实现原理 / 91
4.4.3 echange(V )实现分析 / 92
4.5 Phaser / 94
4.5.1 用Phaser替代CyclicBarrier和CountDownLatch / 94
4.5.2 Phaser新特性 / 95
4.5.3 state变量解析 / 96
4.5.4 阻塞与唤醒（Treiber Stack） / 98
4.5.5 arrive()函数分析 / 99
4.5.6 awaitAdvance()函数分析 / 101
5章 并发容器 / 104
5.1 BlockingQueue / 104
5.1.1 ArrayBlockingQueue / 105
5.1.2 LinkedBlockingQueue / 106
5.1.3 PriorityBlockingQueue / 109
5.1.4 DelayQueue / 111
5.1.5 SynchrousQueue / 113
5.2 BlockingDeque / 121
5.3 CopyOnWrite / 123
5.3.1 CopyOnWriteArrayList / 123
5.3.2 CopyOnWriteArraySet / 124
5.4 ConcurrentLinkedQueue/ Deque / 125
5.5 ConcurrentHashMap / 130
5.5.1 JDK 7中的实现方式 / 130
5.5.2 JDK 8中的实现方式 / 138
5.6 ConcurrentSkipListMap/Set / 152
5.6.1 ConcurrentSkipListMap / 153
5.6.2 ConcurrentSkipListSet / 162
6章 线程池与Future / 163
6.1 线程池的实现原理 / 163
6.2 线程池的类继承体系 / 164
6.3 ThreadPoolEecutor / 165
6.3.1 核心数据结构 / 165
6.3.2 核心配置参数解释 / 165
6.3.3 线程池的优雅关闭 / 167
6.3.4 任务的提交过程分析 / 172
6.3.5 任务的执行过程分析 / 174
6.3.6 线程池的4种拒策略 / 179
6.4 Callable与Future / 180
6.5 ScheduledThreadPool Eecutor / 183
6.5.1 延迟执行和周期性执行的原理 / 184
6.5.2 延迟执行 / 184
6.5.3 周期性执行 / 185
6.6 Eecutors工具类 / 188
7章 ForkJoinPool / 190
7.1 ForkJoinPool用法 / 190
7.2 核心数据结构 / 193
7.3 工作窃取队列 / 195
7.4 ForkJoinPool状态控制 / 198
7.4.1 状态变量ctl解析 / 198
7.4.2 阻塞栈Treiber Stack / 200
7.4.3 ctl变量的初始值 / 201
7.4.4 ForkJoinWorkerThread状态与个数分析 / 201
7.5 Worker线程的阻塞-唤醒机制 / 202
7.5.1 阻塞–入栈 / 202
7.5.2 唤醒–出栈 / 204
7.6 任务的提交过程分析 / 205
7.6.1 内部提交任务pushTask / 206
7.6.2 外部提交任务
addSubmission / 206
7.7 工作窃取算法：任务的执行过程分析 / 207
7.7.1 顺序锁 SeqLock / 209
7.7.2 scanGuard解析 / 210
7.8 ForkJoinTask的fork/join / 212
7.8.1 fork / 213
7.8.2 join的层层嵌套 / 213
7.9 ForkJoinPool的优雅关闭 / 222
7.9.1 关键的terminate变量 / 222
7.9.2 shutdown()与shutdownw()的区别 / 223
8章 CompletableFuture / 226
8.1 CompletableFuture用法 / 226
8.1.1 *简单的用法 / 226
8.1.2 提交任务：runAsync与supplyAsync / 226
8.1.3 链式的CompletableFuture：thenRun、thenAccept和thenApply / 227
8.1.4 CompletableFuture的组合：thenCompose与thenCombine / 229
8.1.5 任意个CompletableFuture的组合 / 231
..........