9787111629436 9787111502067 9787111508243  9787000020009

书   名: java设计模式及实践

 图书定价: 79元

 作 者: [印度]卡马尔米特·辛格（Kamalmeet Singh） [荷兰]艾德里安·伊恩库列斯库（Adrian Ianculescu） [罗马尼亚]路西安-保罗·托尔耶（Lucian-Paul Torje）

 出 版 社: 机械工业出版社

 出版日期: 2019-06-18

 ISBN 号: 9787111629436

 开   本:16开

 页   数:218

 版   次:1-1

内容简介

本书向读者展示Java语言中更加智能化的编码实例。书中首先介绍面向对象编程（OOP）和函数式编程（FP）范式，然后描述常用设计模式的经典使用方法，并解释如何利用函数式编程特性改变经典的设计模式。读者将学习混合使用OOP和FP的实现方式，然后学习响应式编程模型——一种为了编写更好的代码而将OOP和FP结合使用的方法。之后，本书将介绍从MVC架构向微服务和无服务器架构转变的发展趋势，后介绍Java新版本的功能特性及其实践。通过本书的学习，读者可以有效地解决开发应用程序过程中的常见问题，能够轻松地应对各种规模项目的扩展和维护。

目录

译者序

前言

关于作者

关于评审者

第1章 从面向对象到函数式编程 1

1.1 Java简介 1

1.2 Java编程范式 2

1.2.1 命令式编程 2

1.2.2 面向对象编程 3

1.2.3 声明式编程 6

1.2.4 函数式编程 6

1.3 流以及集合的使用 7

1.4 统一建模语言简介 8

1.5 设计模式和原则 11

1.5.1 单一职责原则 12

1.5.2 开闭原则 13

1.5.3 里氏替换原则 13

1.5.4 接口隔离原则 14

1.5.5 依赖倒置原则 16

1.6 总结 16

第2章 创建型模式 18

2.1 单例模式 18

2.1.1 同步锁单例模式 19

2.1.2 拥有双重校验锁机制的同步锁单例模式 20

2.1.3 无锁的线程安全单例模式 21

2.1.4 提前加载和加载 21

2.2 工厂模式 22

2.2.1 简单工厂模式 22

2.2.2 工厂方法模式 25

2.2.3 抽象工厂模式 27

2.2.4 简单工厂、工厂方法与抽象工厂模式之间的对比 28

2.3 建造者模式 29

2.3.1 汽车建造者样例 30

2.3.2 简化的建造者模式 32

2.3.3 拥有方法链的匿名建造者 32

2.4 原型模式 33

2.5 对象池模式 34

2.6 总结 36

第3章 行为型模式 37

3.1 责任链模式 38

3.2 命令模式 40

3.3 解释器模式 43

3.4 迭代器模式 47

3.5 观察者模式 50

3.6 中介者模式 51

3.7 备忘录模式 53

3.8 状态模式 55

3.9 策略模式 55

3.10 模板方法模式 56

3.11 空对象模式 57

3.12 访问者模式 58

3.13 总结 59

第4章 结构型模式 60

4.1 适配器模式 61

4.2 代理模式 66

4.3 装饰器模式 70

4.4 桥接模式 73

4.5 组合模式 76

4.6 外观模式 79

4.7 享元模式 83

4.8 总结 88

第5章 函数式编程 89

5.1 函数式编程简介 89

5.1.1 lambda表达式 91

5.1.2 纯函数 92

5.1.3 引用透明性 92

5.1.4 初等函数 93

5.1.5 高阶函数 93

5.1.6 组合 93

5.1.7 柯里化 93

5.1.8 闭包 94

5.1.9 不可变性 95

5.1.10 函子 95

5.1.11 单子 96

5.2 Java中的函数式编程 97

5.2.1 lambda表达式 97

5.2.2 流 98

5.3 重新实现面向对象编程设计模式 102

5.3.1 单例模式 102

5.3.2 建造者模式 102

5.3.3 适配器模式 103

5.3.4 装饰器模式 103

5.3.5 责任链模式 103

5.3.6 命令模式 104

5.3.7 解释器模式 104

5.3.8 迭代器模式 104

5.3.9 观察者模式 105

5.3.10 策略模式 105

5.3.11 模板方法模式 105

5.4 函数式设计模式 106

5.4.1 MapReduce 106

5.4.2 借贷模式 107

5.4.3 尾调用优化 108

5.4.4 记忆化 109

5.4.5 执行around方法 110

5.5 总结 111

第6章 响应式编程 112

6.1 什么是响应式编程 113

6.2 RxJava简介 114

6.3 安装RxJava 115

6.3.1 Maven下的安装 115

6.3.2 JShell下的安装 116

6.4 Observable、Flowable、Observer和Subscription的含义 116

6.5 创建Observable 118

6.5.1 create操作符 118

6.5.2 defer操作符 119

6.5.3 empty操作符 120

6.5.4 from操作符 120

6.5.5 interval操作符 120

6.5.6 timer操作符 121

6.5.7 range操作符 121

6.5.8 repeat操作符 121

6.6 转换Observable 122

6.6.1 subscribe操作符 122

6.6.2 buffer操作符 122

6.6.3 flatMap操作符 122

6.6.4 groupBy操作符 124

6.6.5 map操作符 124

6.6.6 scan操作符 125

6.6.7 window操作符 125

6.7 过滤Observable 125

6.7.1 debounce操作符 125

6.7.2 distinct操作符 126

6.7.3 elementAt操作符 126

6.7.4 filter操作符 127

6.7.5 first/last操作符 127

6.7.6 sample操作符 128

6.7.7 skip操作符 128

6.7.8 take操作符 128

6.8 组合Observable 128

6.8.1 combine操作符 129

6.8.2 join操作符 129

6.8.3 merge操作符 130

6.8.4 zip操作符 131

6.9 异常处理 131

6.9.1 catch操作符 131

6.9.2 do操作符 132

6.9.3 using操作符 133

6.9.4 retry操作符 133

6.10 线程调度器 134

6.11 Subject 135

6.12 示例项目 136

6.13 总结 139

第7章 响应式设计模式 140

7.1 响应模式 140

7.1.1 请求-响应模式 140

7.1.2 异步通信模式 146

7.1.3 缓存模式 148

7.1.4 扇出与快响应模式 149

7.1.5 快速失败模式 150

7.2 弹性模式 150

7.2.1 断路器模式 150

7.2.2 故障处理模式 151

7.2.3 有限队列模式 151

7.2.4 监控模式 152

7.2.5 舱壁模式 152

7.3 柔性模式 152

7.3.1 单一职责模式 153

7.3.2 无状态服务模式 154

7.3.3 自动伸缩模式 156

7.3.4 自包含模式 156

7.4 消息驱动通信模式 157

7.4.1 事件驱动通信模式 157

7.4.2 出版者-订阅者模式 157

7.4.3 幂等性模式 158

7.5 总结 158

第8章 应用架构的发展趋势 159

8.1 什么是应用架构 159

8.2 分层架构 160

8.2.1 分层架构示例 162

8.2.2 tier和layer的区别 165

8.2.3 分层架构的作用 165

8.2.4 分层架构面临的挑战 165

8.3 MVC架构 166

8.3.1 MVC架构示例 168

8.3.2 更现代的MVC实现 170

8.3.3 MVC架构的作用 171

8.3.4 MVC架构面临的挑战 171

8.4 面向服务架构 171

8.4.1 面向服务架构示例 172

8.4.2 Web服务 173

8.4.3 SOAP与REST 173

8.4.4 企业服务总线 174

8.4.5 面向服务架构的作用 174

8.4.6 面向服务架构面临的挑战 175

8.5 微服务架构 176

8.5.1 微服务架构示例 176

8.5.2 服务间的通信 178

8.5.3 微服务架构的作用 178

8.5.4 微服务架构面临的挑战 178

8.6 无服务器架构 179

8.6.1 无服务器架构示例 179

8.6.2 独立于基础设施规划 184

8.6.3 无服务器架构的作用 184

8.6.4 无服务器架构面临的挑战 184

8.7 总结 185

第9章 Java中的实践 186

9.1 Java简史 186

9.1.1 Java 5的特性 187

9.1.2 Java 8的特性 188

9.1.3 目前官方支持的Java版本 188

9.2 Java 9的实践和新特性 189

9.2.1 Java平台模块化 189

9.2.2 JShell 192

9.2.3 接口中的私有方法 194

9.2.4 流的增强功能 195

9.2.5 创建不可变集合 196

9.2.6 在数组中添加方法 197

9.2.7 Optional类的增强功能 198

9.2.8 新的HTTP客户端 199

9.2.9 Java 9增加的其他功能 200

9.3 Java 10的实践和新特性 201

9.3.1 局部变量类型推断 201

9.3.2 集合的copyOf方法 203

9.3.3 并行垃圾回收机制 204

9.3.4 Java 10增加的其他功能 205

9.4 总结 205 

Java多线程编程核心技术

内容简介

　　Java专家10年经验总结，全程案例式讲解，首本全面介绍Java多线程编程技术的专著。本书以浅白的措辞，结合大量实例，全面讲解Java多线程编程中的并发访问、线程间通信、锁等难突破的技术与应用实践。　　全书共7章。第1章讲解了Java多线程的基础，重点介绍线程类的核心API的使用。第2章讲解对并发访问的控制，即如何写出线程安全的程序。第3章介绍线程间通信，以提高CPU利用率和间的交互，同时增强对线程任务的把控与监督。第4章讲解Lock对象，以更好实现并发访问时的同步处理。第5章讲解移动开发中使用较多的定时器类中的多线程技术，这是计划任务执行里很重要的技术点。第6章讲解如何安全、正确地将单例模式与多线程技术相结合，避免实际应用中可能会出现的麻烦。第7章将前面被遗漏的技术案例在本章节中进行补充，尽量做到不出现技术空白点。

目录

前 言

第1章 Java多线程技能，

1.1 进程和多线程的概念及线程的优点

1.2 使用多线程

1.2.1 继承Thread类

1.2.2 实现Runnable接口

1.2.3 实例变量与线程安全

1.2.4 留意i——与System.out.println（）的异常

1.3 currentThread（）方法

1.4 isAlive（）方法

1.5 sleep（）方法

1.6 getId（）方法

1.7 停止线程

1.7.1 停止不了的线程

1.7.2 判断线程是否是停止状态

1.7.3 能停止的线程——异常法

1.7.4 在沉睡中停止

1.7.5 能停止的线程——暴力停止

1.7.6 方法stop（）与java.lang.ThreadDeath异常

1.7.7 释放锁的不良后果

1.7.8 使用return停止线程

1.8 暂停线程

1.8.1 suspend与resume方法的使用

1.8.2 suspend与resume方法的缺点——独占

1.8.3 suspend与resume方法的缺点——不同步

1.9 yield方法

1.10 线程的优先级

1.10.1 线程优先级的继承特性

1.10.2 优先级具有规则性

1.10.3 优先级具有随机性

1.10.4 看谁运行得快

1.11 守护线程

1.12 本章小结

第2章 对象及变量的并发访问

2.1 synchronized同步方法

2.1.1 方法内的变量为线程安全

2.1.2 实例变量非线程安全

2.1.3 多个对象多个锁

2.1.4 synchronized方法与锁对象

2.1.5 脏读

2.1.6 synchronized锁重入

2.1.7 出现异常，锁自动释放

2.1.8 同步不具有继承性

2.2 synchronized同步语句块

2.2.1 synchronized方法的弊端

2.2.2 synchronized同步代码块的使用

2.2.3 用同步代码块解决同步方法的弊端

2.2.4 一半异步，一半同步

2.2.5 synchronized代码块间的同步性

2.2.6 验证同步synchronized（this）代码块是锁定当前对象的

2.2.7 将任意对象作为对象监视器

2.2.8 细化验证3个结论

2.2.9 静态同步synchronized方法与synchronized（class）代码块

2.2.10 数据类型String的常量池特性

2.2.11 同步synchronized方法无限等待与解决

2.2.12 多线程的死锁

2.2.13 内置类与静态内置类

2.2.14 内置类与同步：实验1

2.2.15 内置类与同步：实验2

2.2.16 锁对象的改变

2.3 volatile关键字

2.3.1 关键字volatile与死循环

2.3.2 解决同步死循环

2.3.3 解决异步死循环

2.3.4 volatile非原子的特性

2.3.5 使用原子类进行i++操作

2.3.6 原子类也并不完全安全

2.3.7 synchronized代码块有volatile同步的功能

2.4 本章总结

第3章 线程间通信

3.1 等待/通知机制

3.1.1 不使用等待/通知机制实现线程间通信

3.1.2 什么是等待/通知机制

3.1.3 等待/通知机制的实现

3.1.4 方法wait（）锁释放与notify（）锁不释放

3.1.5 当interrupt方法遇到wait方法

3.1.6 只通知一个线程

3.1.7 唤醒所有线程

3.1.8 方法wait（long）的使用

3.1.9 通知过早

3.1.10 等待wait的条件发生变化

3.1.11 生产者/消费者模式实现

3.1.12 通过管道进行线程间通信：字节流

3.1.13 通过管道进行线程间通信：字符流

3.1.14 实战：等待/通知之交叉备份

3.2 方法join的使用

3.2.1 学习方法join前的铺垫

3.2.2 用join（）方法来解决

3.2.3 方法join与异常

3.2.4 方法join（long）的使用

3.2.5 方法join（long）与sleep（long）的区别

3.2.6 方法join（）后面的代码提前运行：出现意外

3.2.7 方法join（）后面的代码提前运行：解释意外

3.3 类ThreadLocal的使用

3.3.1 方法get（）与null

3.3.2 验证线程变量的隔离性

3.3.3 解决get（）返回null问题

3.3.4 再次验证线程变量的隔离性

3.4 类InheritableThreadLocal的使用

3.4.1 值继承

3.4.2 值继承再修改

3.5 本章总结

第4章 Lock的使用

4.1 使用ReentrantLock类

4.1.1 使用ReentrantLock实现同步：测试1

4.1.2 使用ReentrantLock实现同步：测试2

4.1.3 使用Condition实现等待/通知用法与解决

4.1.4 正确使用Condition实现等待/通知

4.1.5 使用多个Condition实现通知部分线程：用法

4.1.6 使用多个Condition实现通知部分线程：正确用法

4.1.7 实现生产者/消费者模式：一对一交替打印

4.1.8 实现生产者/消费者模式：多对多交替打印

4.1.9 公平锁与非公平锁

4.1.10 方法getHoldCount（）、getQueueLength（）和getWaitQueueLength（）的测试

4.1.11 方法hasQueuedThread（）、hasQueuedThreads（）和hasWaiters（）的测试

4.1.12 方法isFair（）、isHeldByCurrentThread（）和isLocked（）的测试

4.1.13 方法lockInterruptibly（）、tryLock（）和tryLock（long timeout，TimeUnit unit）的测试

4.1.14 方法awaitUninterruptibly（）的使用

4.1.15 方法awaitUntil（）的使用

4.1.16 使用Condition实现顺序执行

4.2 使用ReentrantReadWriteLock类

4.2.1 类ReentrantReadWriteLock的使用：读读共享

4.2.2 类ReentrantReadWriteLock的使用：写写互斥

4.2.3 类ReentrantReadWriteLock的使用：读写互斥

4.2.4 类ReentrantReadWriteLock的使用：写读互斥

4.3 本章总结

第5章 定时器Timer

5.1 定时器Timer的使用

5.1.1 方法schedule（TimerTask task， Date time）的测试

5.1.2 方法schedule（TimerTask task， Date firstTime， long period）的测试

5.1.3 方法schedule（TimerTask task， long delay）的测试

5.1.4 方法schedule（TimerTask task， long delay， long period）的测试

5.1.5 方法scheduleAtFixedRate（TimerTask task， Date firstTime， long period）的测试

5.2 本章总结

第6章 单例模式与多线程

6.1 加载/"饿汉模式"

6.2 加载/"懒汉模式"

6.3 使用静态内置类实现单例模式

6.4 序列化与反序列化的单例模式实现

6.5 使用static代码块实现单例模式

6.6 使用enum枚举数据类型实现单例模式

6.7 完善使用enum枚举实现单例模式

6.8 本章总结

第7章 拾遗增补

7.1 线程的状态

7.1.1 验证NEW、RUNNABLE和TERMINATED

7.1.2 验证TIMED_WAITING

7.1.3 验证BLOCKED

7.1.4 验证WAITING

7.2 线程组

7.2.1 线程对象关联线程组：1级关联

7.2.2 线程对象关联线程组：多级关联

7.2.3 线程组自动归属特性

7.2.4 获取根线程组

7.2.5 线程组里加线程组

7.2.6 组内的线程批量停止

7.2.7 递归与非递归取得组内对象

7.3 使线程具有有序性

7.4 SimpleDateFormat非线程安全

7.4.1 出现异常

7.4.2 解决异常方法1

7.4.3 解决异常方法2

7.5 线程中出现异常的处理

7.6 线程组内处理异常

7.7 线程异常处理的传递

7.8 本章总结

Java并发编程的艺术

内容简介

　　并发编程领域的扛鼎之作，作者是阿里和的Java技术专家，对并发编程有非常深入的研究，《Java并发编程的艺术》是他们多年一线开发经验的结晶。本书的部分内容在出版早期发表在Java并发编程网和InfoQ等技术社区，得到了非常高的评价。它选取了Java并发编程中核心的技术进行讲解，从JDK源码、JVM、CPU等多角度全面剖析和讲解了Java并发编程的框架、工具、原理和方法，对Java并发编程进行了为深入和透彻的阐述。

　　《Java并发编程的艺术》内容涵盖Java并发编程机制的底层实现原理、Java内存模型、Java并发编程基础、Java中的锁、并发容器和框架、原子类、并发工具类、线程池、Executor框架等主题，每个主题都做了深入的讲解，同时通过实例介绍了如何应用这些技术。

目录

前　言

第1章　并发编程的挑战 1

1.1　上下文切换 1

1.1.1　多线程一定快吗 1

1.1.2　测试上下文切换次数和时长 3

1.1.3　如何减少上下文切换 3

1.1.4　减少上下文切换实战 4

1.2　死锁 5

1.3　资源限制的挑战 6

1.4　本章小结 7

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

2.1　volatile的应用 8

2.2　synchronized的实现原理与应用 11

2.2.1　Java对象头 12

2.2.2　锁的升级与对比 13

2.3　原子操作的实现原理 16

2.4　本章小结 20

第3章　Java内存模型 21

3.1　Java内存模型的基础 21

3.1.1　并发编程模型的两个关键问题 21

3.1.2　Java内存模型的抽象结构 22

3.1.3　从源代码到指令序列的重排序 23

3.1.4　并发编程模型的分类 24

3.1.5　happens-before简介 26

3.2　重排序 27

3.2.1　数据依赖性 28

3.2.2　as-if-serial语义 28

3.2.3　程序顺序规则 29

3.2.4　重排序对多线程的影响 29

3.3　顺序一致性 31

3.3.1　数据竞争与顺序一致性 31

3.3.2　顺序一致性内存模型 32

3.3.3　同步程序的顺序一致性效果 34

3.3.4　未同步程序的执行特性 35

3.4　volatile的内存语义 38

3.4.1　volatile的特性 38

3.4.2　volatile写-读建立的happens-before关系 39

3.4.3　volatile写-读的内存语义 40

3.4.4　volatile内存语义的实现 42

3.4.5　JSR-133为什么要增强volatile的内存语义 46

3.5　锁的内存语义 47

3.5.1　锁的释放-获取建立的

　　　happens-before关系 47

3.5.2　锁的释放和获取的内存语义 48

3.5.3　锁内存语义的实现 50

3.5.4　concurrent包的实现 54

3.6　final域的内存语义 55

3.6.1　final域的重排序规则 55

3.6.2　写final域的重排序规则 56

3.6.3　读final域的重排序规则 57

3.6.4　final域为引用类型 58

3.6.5　为什么final引用不能从构造函数内“溢出” 59

3.6.6　final语义在处理器中的实现 61

3.6.7　JSR-133为什么要增强f?inal的语义 62

3.7　happens-before 62

3.7.1　JMM的设计 62

3.7.2　happens-before的定义 64

3.7.3　happens-before规则 65

3.8　双重检查锁定与初始化 67

3.8.1　双重检查锁定的由来 67

3.8.2　问题的根源 69

3.8.3　基于volatile的解决方案 71

3.8.4　基于类初始化的解决方案 72

3.9　Java内存模型综述 78

3.9.1　处理器的内存模型 78

3.9.2　各种内存模型之间的关系 80

3.9.3　JMM的内存可见性保证 80

3.9.4　JSR-133对旧内存模型的修补 81

3.10　本章小结 82

第4章　Java并发编程基础 83

4.1　线程简介 83

4.1.1　什么是线程 83

4.1.2　为什么要使用多线程 84

4.1.3　线程优先级 85

4.1.4　线程的状态 87

4.1.5　Daemon线程 90

4.2　启动和终止线程 91

4.2.1　构造线程 91

4.2.2　启动线程 92

4.2.3　理解中断 92

4.2.4　过期的suspend()、resume()和stop() 93

4.2.5　安全地终止线程 95

4.3　线程间通信 96

4.3.1　volatile和synchronized关键字 96

4.3.2　等待/通知机制 98

4.3.3　等待/通知的经典范式 101

4.3.4　管道输入/输出流 102

4.3.5　Thread.join()的使用 103

4.3.6　ThreadLocal的使用 105

4.4　线程应用实例 106

4.4.1　等待超时模式 106

4.4.2　一个简单的数据库连接池示例 106

4.4.3　线程池技术及其示例 110

4.4.4　一个基于线程池技术的简单Web服务器 114

4.5　本章小结 118

第5章　Java中的锁 119

5.1　Lock接口 119

5.2　队列同步器 121

5.2.1　队列同步器的接口与示例 121

5.2.2　队列同步器的实现分析 124

5.3　重入锁 136

5.4　读写锁 140

5.4.1　读写锁的接口与示例 141

5.4.2　读写锁的实现分析 142

5.5　LockSupport工具 146

5.6　Condition接口 147

5.6.1　Condition接口与示例 148

5.6.2　Condition的实现分析 150

5.7　本章小结 154

第6章　Java并发容器和框架 155

6.1　ConcurrentHashMap的实现原理与使用 155

6.1.1　为什么要使用ConcurrentHashMap 155

6.1.2　ConcurrentHashMap的结构 156

6.1.3　ConcurrentHashMap的初始化 157

6.1.4　定位Segment 159

6.1.5　ConcurrentHashMap的操作 160

6.2　ConcurrentLinkedQueue 161

6.2.1　ConcurrentLinkedQueue的结构 162

6.2.2　入队列 162

6.2.3　出队列 165

6.3　Java中的阻塞队列 167

6.3.1　什么是阻塞队列 167

6.3.2　Java里的阻塞队列 168

6.3.3　阻塞队列的实现原理 172

6.4　Fork/Join框架 175

6.4.1　什么是Fork/Join框架 175

6.4.2　工作窃取算法 176

6.4.3　Fork/Join框架的设计 177

6.4.4　使用Fork/Join框架 177

6.4.5　Fork/Join框架的异常处理 179

6.4.6　Fork/Join框架的实现原理 179

6.5　本章小结 181

第7章　Java中的13个原子操作类 182

7.1　原子更新基本类型类 182

7.2　原子更新数组 184

7.3　原子更新引用类型 185

7.4　原子更新字段类 187

7.5　本章小结 188

第8章　Java中的并发工具类 189

8.1　等待多线程完成的CountDownLatch 189

8.2　同步屏障CyclicBarrier 191

8.2.1　CyclicBarrier简介 191

8.2.2　CyclicBarrier的应用场景 193

8.2.3　CyclicBarrier和CountDownLatch的区别 195

8.3　控制并发线程数的Semaphore 196

8.4　线程间交换数据的Exchanger 198

8.5　本章小结 199

第9章　Java中的线程池 200

9.1　线程池的实现原理 200

9.2　线程池的使用 203

9.2.1　线程池的创建 203

9.2.2　向线程池提交任务 205

9.2.3　关闭线程池 205

9.2.4　合理地配置线程池 206

9.2.5　线程池的监控 206

9.3　本章小结 207

第10章　Executor框架 208

10.1　Executor框架简介 208

10.1.1　Executor框架的两级调度模型 208

10.1.2　Executor框架的结构与成员 208

10.2　ThreadPoolExecutor详解 213

10.2.1　FixedThreadPool详解 213

10.2.2　SingleThreadExecutor详解 214

10.2.3　CachedThreadPool详解 215

10.3　ScheduledThreadPoolExecutor详解 217

10.3.1　ScheduledThreadPoolExecutor的运行机制 217

10.3.2　ScheduledThreadPoolExecutor的实现 218

10.4　FutureTask详解 221

10.4.1　FutureTask简介 222

10.4.2　FutureTask的使用 222

10.4.3　FutureTask的实现 224

10.5　本章小结 227

第11章　Java并发编程实践 228

11.1　生产者和消费者模式 228

11.1.1　生产者消费者模式实战 229

11.1.2　多生产者和多消费者场景 231

11.1.3　线程池与生产消费者模式 234

11.2　线上问题定位 234

11.3　性能测试 236

11.4　异步任务池 238

11.5　本章小结 240

^_^:ddce62a8125e0497ec6d9e881dd2381c