9787111657705 9787111599937 9787121360350

Java高并发编程详解：深入理解并发核心库



作者 : 汪文君 著



定价 : 99.00 元



出版社 : 机械工业出版社



出版时间 : 2020/06



语种 : 简体中文



种类 : 科技类书籍



开本 : 16开



页数 : 410 页



ISBN : 978-7-111-65770-5






本书分了个部分，一部分详细讲解JDK高并发核心库，包括JDK1.8、JDK1.9对高并发的支持。二部分主要讲解Actor模型的实现Akka是如何应用在高并发编程环境中的。三部分系统讲解RJava以及Reactive的高并发编程模型。部分站拾遗补漏介绍Google Guava、Disruptor等开源框架提供的高并发解决方案。








推荐序一

推荐序二

推荐序三

推荐序

前 言

1章 JMH 1

1.1 JMH简介 1

1.2 JMH快速入门 1

1.2.1 用main方法进行测试 1

1.2.2 用JMH进行微基准测试 3

1.3 JMH的基本用法 6

1.3.1 @Benchmark标记基准测试方法 7

1.3.2 Warmup以及Measurement 8

1.3.3 大BenchmarkMode 10

1.3.4 OutputTimeUnit 14

1.3.5 三大State的使用 14

1.3.6 @Param的妙用 19

1.3.7 JMH的测试套件（Fiture） 23

1.3.8 CompilerControl 26

1.4 编写正确的微基准测试以及用法 27

1.4.1 编写正确的微基准测试用例 28

1.4.2 一些的用法 38

1.5 JMH的Profiler 45

1.5.1 StackProfiler 45

1.5.2 GcProfiler 47

1.5.3 ClassLoaderProfiler 51

1.5.4 CompilerProfiler 54

1.6 本章总结 56

2章 Java并发包之原子类型详解 57

2.1 AtomicInteger详解 58

2.1.1 性能测试对比 58

2.1.2 AtomicInteger的基本用法 61

2.1.3 AtomicInteger内幕 66

2.1.4 AtomicInteger总结 68

2.2 AtomicBoolean详解 69

2.2.1 AtomicBoolean的基本用法 69

2.2.2 AtomicBoolean内幕 71

2.2.3 Try Lock显式锁的实现 71

2.2.4 AtomicBoolean总结 74

2.3 AtomicLong详解 74

2.4 AtomicReference详解 76

2.4.1 AtomicReference的应用场景 77

2.4.2 AtomicReference的基本用法 83

2.4.3 AtomicReference的内幕 84

2.4.4 AtomicReference总结 86

2.5 AtomicStampedReference详解 86

2.5.1 CAS算法ABA问题 86

2.5.2 AtomicStampedReference详解 87

2.5.3 AtomicStampedReference总结 89

2.6 AtomicArray详解 89

2.7 AtomicFieldUpdater详解 90

2.7.1 原子性更新对象属性 90

2.7.2 注意事项 91

2.7.3 AtomicFieldUpdater总结 93

2.8 sun.misc.Unsafe详解 93

2.8.1 如何获取Unsafe 94

2.8.2 JNI、Java和C/C++混合编程 95

2.8.3 危险的Unsafe 98

2.8.4 sun.misc.Unsafe总结 100

2.9 本章总结 100

3章 Java并发包之工具类详解 102

3.1 CountDownLatch工具详解 102

3.1.1 等待所有子任务结束 103

3.1.2 CountDownLatch的其他方法及总结 106

3.2 CyclicBarrier工具详解 107

3.2.1 等待所有子任务结束 107

3.2.2 CyclicBarrier的循环特性 110

3.2.3 CyclicBarrier的其他方法以及总结 114

3.2.4 CyclicBarrier VS. CountDownLatch 116

3.3 Echanger工具详解 116

3.3.1 一对线程间的数据交换 116

3.3.2 Echanger的方法详解 121

3.3.3 Echanger总结 123

3.4 Semaphore工具详解 124

3.4.1 Semaphore限制同时在线的用户数量 124

3.4.2 使用Semaphore定义try lock 127

3.4.3 Semaphore其他方法详解 129

3.4.4 扩展Semaphore增强release 135

3.4.5 Semaphore总结 138

3.5 Phaser工具详解 138

3.5.1 Phaser的基本用法 138

3.5.2 Phase（阶段）以及Phaser方法详解 144

3.5.3 Phaser层级关系 148

3.5.4 Phaser总结 149

3.6 Lock&ReentrantLock详解 150

3.6.1 Lock及ReentrantLock方法详解 150

3.6.2 正确使用显式锁Lock 152

3.6.3 ReentrantLock VS. Synchronized关键字 158

3.6.4 显式锁Lock总结 164

3.7 ReadWriteLock&ReentrantRead-WriteLock详解 165

3.7.1 读写锁的基本使用方法 165

3.7.2 读写锁的方法 167

3.7.3 基准测试性能对比 167

3.7.4 读写锁总结 170

3.8 Condition详解 171

3.8.1 初识Condition 171

3.8.2 Condition接口方法详解 174

3.8.3 使用Condition之生产者消费者 177

3.8.4 Condition总结 181

3.9 StampedLock详解 181

3.9.1 读写锁的饥饿写问题 182

3.9.2 StampedLock的使用 183

3.9.3 与其他锁的性能对比 185

3.9.4 StampedLock总结 191

3.10 Guava之Monitor详解 192

3.10.1 Monitor及Guard 192

3.10.2 Monitor的其他方法 194

3.10.3 Monitor总结 194

3.11 Guava之RateLimiter详解 194

3.11.1 RateLimiter的基本使用 195

3.11.2 RateLimiter的限流作——漏桶算法 196

3.11.3 令牌环桶算法 201

3.11.4 RateLimiter总结 204

3.12 本章总结 204

4章 Java并发包之并发容器详解 205

4.1 链表 206

4.1.1 基本的链表 206

4.1.2 优先级链表 210

4.1.3 跳表（SkipList） 213

4.1.4 链表总结 221

4.2 BlockingQueue（阻塞队列） 221

4.2.1 ArrayBlockingQueue 222

4.2.2 PriorityBlockingQueue 226

4.2.3 LinkedBlockingQueue 228

4.2.4 DelayQueue 228

4.2.5 SynchrousQueue 231

4.2.6 LinkedBlockingDeque 233

4.2.7 LinkedTransferQueue 234

4.2.8 BlockingQueue总结 236

4.3 ConcurrentQueue（并发队列） 237

4.3.1 并发队列的性能 239

4.3.2 并发队列在使用中需要注意的问题 241

4.3.3 并发队列总结 245

4.4 ConcurrentMap（并发映） 245

4.4.1 ConcurrentHashMap简介 245

4.4.2 ConcurrentSkipListMap简介 247

4.4.3 并发映总结 247

4.5 写时拷贝算法（Copy On Write） 248

4.5.1 CopyOnWrite读实现作分析 249

4.5.2 CopyOnWrite写实现作分析 249

4.5.3 CopyOnWrite总结 250

4.6 高并发无锁（Lock Free）数据结构的实现 250

4.6.1 高并发无锁链表的实现 250

4.6.2 Lock Free数据结构的测试 253

4.6.3 本节总结 255

4.7 本章总结 255

5章 Java并发包之EecutorService详解 256

5.1 Eecutor&EecutorService详解 256

5.1.1 ThreadPoolEecutor详解 257

5.1.2 ScheduledEecutorService详解 265

5.1.3 关闭EecutorService 271

5.1.4 Eecutors详解 273

5.1.5 EecutorService总结 276

5.2 Future和Callback 277

5.2.1 Future详解 277

5.2.2 EecutorService与Future 280

5.2.3 Future的不足之处 282

5.2.4 Google Guava的Future 282

5.2.5 Future总结 284

5.3 ForkJoinPool 详解 284

5.3.1 Fork/Join Framework介绍 284

5.3.2 ForkJoinTask详解 285

5.3.3 ForkJoinPool总结 289

5.4 CompletionService详解 289

5.4.1 EecutorService执行批量任务的缺陷 289

5.4.2 CompletionService详解 291

5.4.3 CompletionService总结 294

5.5 CompletableFuture详解 294

5.5.1 CompletableFuture的基本用法 294

5.5.2 任务的异步运行 296

5.5.3 异步任务链 296

5.5.4 合并多个Future 298

5.5.5 多Future的并行计算 299

5.5.6 错误处理 299

5.5.7 JDK 9对CompletableFuture的进一步支持 300

5.5.8 CompletableFuture总结 300

5.6 本章总结 301

6章 Java Streams详解 302

6.1 Stream介绍及其基本作 302

6.1.1 如何创建Stream 303

6.1.2 Stream之Intermediate作 306

6.1.3 Stream之Terminal作 312

6.1.4 NumericStream详解 317

6.1.5 Stream总结 320

6.2 Collector在Stream中的使用 320

6.2.1 初识Collector 321

6.2.2 Collectors用法详解 324

6.2.3 自定义Collector 335

6.2.4 Collector总结 336

6.3 Parallel Stream详解 337

6.3.1 并行流Parallel Stream 337

6.3.2 Spliterator 详解 340

6.3.3 Spliterator总结 343

6.4 本章总结 344

7章 Metrics（Powerful Toolkit For Measure） 345

7.1 Metrics快速入门 345

7.1.1 如何监控度量应用程序 345

7.1.2 Metrics环境搭建 346

7.2 五大Metric详解 346

7.2.1 Meter 347

7.2.2 Gauge 349

7.2.3 Counter 360

7.2.4 Histogram 362

7.2.5 Timer 370

7.3 Reporter详解 372

7.3.1 ConsoleReporter 373

7.3.2 LogReporter 376

7.3.3 JMXReporter 378

7.3.4 CsvReporter 379

7.4 Metrics Plugins 380

7.4.1 Health Check 381

7.4.2 JVM Instrumentation 386

7.5 深入Metrics源码 387

7.5.1 MetricRegistry如何工作 388

7.5.2 Reporter如何工作 392

7.5.3 拾遗补漏 394

7.6 本章总结 396



Java高并发编程详解：多线程与架构设计


本书主要包含个部分：
部分主要阐述Thread的基础知识，详细介绍线程的API使用、线程安全、线程间数据通信，以及如何保护共享资源等内容，它是深入学习多线程内容的基础。
二部分引入了ClassLoader，这是因为ClassLoader与线程不无关系，我们可以通过synchronized关键字，或者Lock等显式锁的方式在代码的编写阶段对共享资源进行数据一致性保护，那么一个Class在完成初始化的整个过程到后在方法区（JDK8 以后在元数据空间）其数据结构是怎样确保数据一致性的呢？这就需要对ClassLoader有一个比较全面的认识和了解。
三部分详细、深入地介绍volatile关键字的语义，volatile关键字在Java中非常重要，可以说它奠定了Java核心并发包的高效运行，在这一部分中，我们通过实例展示了如何使用volatile关键字以及非常详细地介绍了Java内存模型等知识。
本书的部分，站在程序架构设计的角度深入讲解了如何设计高效灵活的多线程应用程序，这一部分长达15个章节，其重要程度可见一斑。


一部分：多线程基础 20
1章：快速认识线程 22
1.1 线程的介绍 22
1.2 快速创建并启动一个线程 22
1.2.1 尝试并行运行 23
1.2.2 并发运行交替输出 24
1.2.3 使用Jconsole观察线程 25
1.3 线程的生命周期详解 26
1.3.1 线程的NEW状态 27
1.3.2 线程的RUNNABLE状态 28
1.3.3 线程的 RUNNING状态 28
1.3.4 线程的BLOCKED状态 29
1.3.5 线程的TERMINATED状态 29
1.4 线程的start方法剖析--模板设计模式在Thread中的应用 30
1.4.1 Thread start方法源码分析以及注意事项 30
1.4.2 模板设计模式在Thread中的应用 33
1.4.3 Thread模拟营业大厅叫号机程序 34
1.5 Runnable接口的引入以及策略模式在Thread中的使用 39
1.5.1 Runnable的职责 39
1.5.2 策略模式在Thread中的应用 40
1.5.3 模拟营业大厅叫号机程序 42
1.6 本章总结 43
2章：深入理解Thread构造函数 45
2.1 线程的命名 45
2.1.1 线程的默认命名 45
2.1.2 命名线程 46
2.1.3 修改线程的名字 47
2.2 线程的父子关系 48
2.3 Thread与ThreadGroup 48
2.4 Thread与Runnable 50
2.5 Thread与JVM虚拟机栈 50
2.5.1 Thread与Stacksize 51
2.5.2 JVM内存结构 53
2.5.3 Thread与虚拟机栈 58
2.6 守护线程 62
2.6.1 什么是守护线程 62
2.6.2 守护线程的作用 64
2.7 本章总结 64
3章：Thread API的详细介绍 66
3.1 线程sleep 66
3.1.1 sleep方法介绍 66
3.1.2 使用TimeUnit替代Thread.sleep 67
3.2 线程yield 68
3.2.1 yield方法介绍 68
3.2.2 yield vs sleep 69
3.3 设置线程的优先级 69
3.3.1 线程优先级介绍 70
3.3.2 线程优先级源码分析 71
3.3.3 关于优先级的一些总结 72
3.4 获取线程ID 73
3.5 获取当前线程 73
3.6 设置线程上下文类加载器 74
3.7 线程interrupt 75
3.7.1 interrupt 75
3.7.2 isInterrupted 77
3.7.3 interrupted 79
3.7.4 interrupt注意事项 81
3.8 线程join 82
3.8.1 线程join方法详解 83
3.8.2 join方法结合实战 85
3.9 如何关闭一个线程 90
3.9.1 正常关闭 90
3.9.2 异常出 94
3.9.3 进程假死 94
3.10 本章总结 95
4章：线程安全与数据同步 97
4.1 数据同步 97
4.1.1 数据不一致问题的引入 97
4.1.2 数据不一致问题原因分析 99
4.2 初识 synchronized关键字 101
4.2.1 什么是synchronized 102
4.2.2 synchronized关键字的用法 103
4.3 深入synchronized关键字 105
4.3.1 线程堆栈分析 105
4.3.2 JVM指令分析 108
4.3.3 使用synchronized需要注意的问题 112
4.4 This Monitor和Class Monitor的详细介绍 114
4.4.1 this monitor 114
4.4.2 class monitor 117
4.5 程序死锁的原因以及如何诊断 120
4.5.1 程序死锁 120
4.5.2 程序死锁举例 121
4.5.3 死锁诊断 124
4.6 本章总结 126
5章：线程间通信 127
5.1 同步阻塞与异步非阻塞 127
5.1.1 同步阻塞消息处理 127
5.1.2 异步非阻塞消息处理 128
5.2 单线程间通信 129
5.2.1 初识wait和tify 129
5.2.2 wait和tify方法详解 133
5.2.3 wait和tify注意事项 135
5.2.4 wait vs sleep 137
5.3 多线程间通信 137
5.3.1 生产者消费者 137
5.3.2 线程休息室wait set 140
5.4 自定义显式锁BooleanLock 141
5.4.1 synchronized关键字的缺陷 142
5.4.2 显式锁BooleanLock 143
5.5 本章总结 153
6章：ThreadGroup详细讲解 155
6.1 ThreadGroup与Thread 155
6.2 创建Thread Group 155
6.3 拷贝Thread数组和ThreadGroup数组 157
6.3.1 拷贝Thread数组 157
6.3.2 拷贝ThreadGroup数组 159
6.4 ThreadGroup作 160
6.4.1 ThreadGroup的基本作 161
6.4.2 ThreadGroup的interrupt 164
6.4.3 ThreadGroup的destroy 166
6.4.4 守护ThreadGroup 168
6.5 本章总结 169
7章：Hook线程以及捕获线程执行异常 170
7.1 获取线程运行时异常 170
7.1.1 UncaughtEceptionHandler介绍 170
7.1.2 UncaughtEceptionHandler实例 171
7.1.3 UncaughtEceptionHandler源码分析 173
7.2 注入钩子线程（Hook） 175
7.2.1 Hook线程介绍 175
7.2.2 Hook线程实战 177
7.2.3 Hook线程应用场景以及注意事项 179
7.3 本章总结 179
8章：线程池原理以及自定义线程池 180
8.1 线程池原理 180
8.2 线程池实现 181
8.2.1 线程池接口定义 182
8.2.2 线程池详细实现 188
8.3 线程池应用 198
8.4 本章总结 202
二部分：Java ClassLoader 204
9章 类的加载过程 205
9.1 类的加载过程介绍 205
9.2 类的主动使用和被动使用 206
9.3 类加载过程详解 209
9.3.1 类的加载阶段 210
9.3.2 类的连接阶段 212
9.3.3 类的初始化阶段 219
9.4 本章总结 221
10章 JVM类加载器 224
10.1 JVM内置三大类加载器 224
10.1.1 根类加载器介绍 225
10.1.2 扩展类加载器介绍 226
10.1.3 系统类加载器介绍 227
10.2 自定义类加载器 227
10.2.1 自定义类加载器，问候世界 228
10.2.2 双委托机制详细介绍 233
10.2.3 破坏双委托机制 236
10.2.4 类加载器命名空间，运行时包，类的卸载等 239
10.3 本章总结 246
11章 线程上下文类加载器 249
11.1 为什么需要线程上下文类加载器 249
11.2 数据库驱动的初始化源码分析 250
三部分 深入理解volatile关键字 254
12章 volatile关键字的介绍 255
12.1 初识volatile关键字 255
12.2 机器硬件CPU 257
12.3 Java 内存模型 262
13章 深入volatile关键字 265
13.1 并发编程的三个重要特性 265
13.1.1 原子性 265
13.1.2 可见性 266
13.1.3 有序性 266
13.2 JMM如何保证三大特性 268
13.2.1 JMM与原子性 269
13.2.2 JMM与可见性 271
13.2.3 JMM与有序性 272
13.3 volatile关键字深入解析 273
13.3.1 volatile关键字的语义 274
13.3.2 volatile的原理和实现机制 277
13.3.3 volatile的使用场景 278
......



Java多线程与Socket：实战微服务框架


本书从实战角度出发，首先介绍Java多线程、Socket、Spring、动态代理、动态字节码、序列化等技术在构建分布式微服务框架中的应用。然后介绍一种微服务框架的架构设计与编程实践，并将这一微服务框架分解为底层Socket通信、服务注册与发现、服务暴与引用、远程方法调用等层面，逐一深入讲解。这里重点介绍作者如何活用相关技术一步步地构建微服务框架的基础RPC框架并分享了相应的性能调优经验。后介绍微服务架构中配套的服务治理系统的设计与实现方案，包括服务的设计、配置、管理与监控。


1章　多线程基础
1．1　多线程的概念
1．1．1　进程与线程
1．1．2　并发与并行
1．1．3　线程状态
1．2　Thread线程类
1．2．1　基本用法与思考
1．2．2　常用方法介绍
1．2．3　wait和sleep的区别
1．2．4　sleep和yield的区别
1．3　Runnable接口
1．4　线程池
1．4．1　Eecutors
1．4．2　EecutorService
1．4．3　ThreadPoolEecutor
1．4．4　基本用法与思考
1．5　Callable与Future
1．6　线程安全与效率
1．6．1　什么是线程安全
1．6．2　线程同步
1．6．3　饥饿与公平
1．6．4　锁与死锁
1．6．5　线程中断
1．7　编程进阶
1．7．1　volatile关键字
1．7．2　synchronized关键字
1．7．3　wait/tify/tifyAll
1．7．4　CAS作
1．7．5　atomic包
1．7．6　Lock自旋锁
1．7．7　Condition条件变量
1．7．8　线程安全容器
1．7．9　ThreadLocal类
1．7．10　CountDownLatch计数器
1．7．11　CyclicBarrier栅栏
1．7．12　Semaphore信号量
1．7．13　fork/join框架
2章　Socket基础
2．1　TCP与Socket
2．2　TCP的通信过程
2．2．1　基本过程
2．2．2　建立连接
2．2．3　全双工异步通信
2．2．4　断开连接
2．2．5　优雅地断开
2．2．6　半……连接
2．3　通信方式
2．3．1　长连接与短连接
2．3．2　线程模型
2．3．3　拆包与组包
2．3．4　断包与粘包
2．3．5　数据包的结构
2．4　BIO
2．4．1　典型编程模型
2．4．2　关键API概述
2．4．3　字符流传输
2．4．4　字节流传输
2．4．5　传输多笔数据
2．5　NIO
2．5．1　NIO简介
2．5．2　Buffer
2．5．3　Channel
2．5．4　Selector
2．5．5　Scatter/Gather
2．5．6　Pipe
2．5．7　内存映像文件
2．5．8　文件传输示例
2．5．9　“聊天室”示例
2．6　AIO
2．6．1　AIO简介
2．6．2　关键API概述
2．6．3　示例代码
3章　Spring与Spring Cloud
3．1　Spring简介
3．2　IoC容器
3．2．1　IoC的概念
3．2．2　Spring中的bean
3．2．3　XML配置方式
3．2．4　注解配置方式
3．2．5　用Java类来配置
3．2．6　BeanFactory与FactoryBean
3．2．7　ApplicationContet与ApplicationContetAware
3．2．8　动态注册bean配置
3．2．9　ApplicationListener与容器事件
3．3　bean的基本配置
3．3．1　scope属性
3．3．2　parent与abstract
3．3．3　factory-bean与factory-method
3．3．4　bean的初始化与释放
3．4　依赖注入
3．4．1　setter注入
3．4．2　工厂方式注入
3．4．3　构造器注入
3．4．4　注解注入
3．5　Spring Boot
3．5．1　快速创建工程
3．5．2　编码与测试
3．5．3　打包部署
3．5．4　辅助开发工具
3．5．5　监控功能
3．6　Spring Cloud
3．6．1　Spring Cloud简介
3．6．2　架构设计
3．6．3　创建应用
3．6．4　服务的注册与发现
3．6．5　服务配置
3．6．6　Ribbon负载均衡
3．6．7　Feign服务调用
3．6．8　Hystri
3．6．9　Zuul服务路由
3．6．10　服务监控
4章　动态代理
4．1　代理模式
4．2　静态代理
4．3　类的装载
4．4　Java反
4．5　JDK动态代理
4．6　CGLIB动态代理
4．7　Java Compiler API
4．8　Javassist动态代理
5章　对象序列化
5．1　什么是序列化
5．2　Java序列化
5．2．1　基本用法
5．2．2　关于serialVersionUID
5．2．3　自定义序列化
5．2．4　封装实现代码
5．3　Hessian序列化
5．4　Kryo序列化
5．5　FST序列化
5．6　其他序列化组件
5．7　集成与扩展
5．7．1　优雅地集成
5．7．2　使用Java SPI
5．7．3　使用Spring
6章　框架设计
6．1　总体结构
6．1．1　逻辑架构
6．1．2　框架设计概述
6．1．3　RPC原理
6．1．4　工程结构
6．1．5　依赖的jar包
6．1．6　主要的类
6．2　初始化过程
6．2．1　Spring配置
6．2．2　应用节点的启动
6．2．3　Web容器的启动
6．2．4　RpcCore的初始化
6．2．5　RpcContet的初始化
6．3　服务的暴
6．3．1　服务暴配置
6．3．2　方法配置与ID
6．3．3　内置的服务方法
6．3．4　服务提供方本地调用器
6．3．5　服务提供方代理生成器
6．3．6　注册要暴的服务
6．4　服务的引用
6．4．1　服务引用配置
6．4．2　本地引用工厂类
6．4．3　注册本地引用工厂
6．4．4　本地引用与方法ID
6．5　服务的注册与发现
6．5．1　注册表集合
6．5．2　注册表的同步
6．5．3　注册表的解析
6．5．4　提交注册表
6．5．5　注册表推送
6．5．6　注册表检查
6．6　优雅地停机
6．6．1　停机的过程
6．6．2　停机钩子
6．6．3　Web容器的关闭
6．6．4　RpcCore的关闭
6．6．5　停机通知的处理
7章　方法调用
7．1　方法调用类型
7．2　同步调用
7．2．1　同步调用的时序
7．2．2　同步调用的发起
7．2．3　负载均衡
7．2．4　指定服务提供者
7．2．5　失败转移
7．2．6　发送调用请求
7．2．7　处理调用请求
7．2．8　处理调用响应
7．3　异步调用
7．3．1　异步调用的时序
7．3．2　异步调用的发起
7．3．3　异步调用的执行
7．3．4　方法调用对象
7．4　同步/异步通知
7．5　异步回调
7．6　广播调用与广播通知
7．6．1　广播示例
7．6．2　广播代码
8章　通信层实现
8．1　Socket通信框架
8．1．1　Netty与Mina
8．1．2　为什么要自己写
8．1．3　是NIO还是AIO
8．1．4　设计思路
8．1．5　实际结构
8．2　通信协议
8．2．1　传输对象
8．2．2　数据包结构
8．2．3　拆包与发送
8．2．4　接收并组包
8．3　连接的建立
8．3．1　工作模型
8．3．2　开始
8．3．3　发起连接
8．3．4　绑定连接
8．3．5　断线检测
9章　性能测试与调优
9．1　性能调优概述
9．1．1　性能指标
9．1．2　性能瓶颈
9．1．3　环境因素
9．2　压力测试
9．2．1　测试方法
9．2．2　场景设计
9．2．3　测试环境
9．2．4　Dubbo配置
9．2．5　测试程序
9．3　线程池调优
9．3．1　调整线程池的大小
9．3．2　选择合适的队列
9．3．3　线程的管理逻辑
9．3．4　选择拒策略
9．4　优化线程同步
9．4．1　减少上下文切换
9．4．2　避免线程滥用
9．4．3　避免过多的锁
9．4．4　synchronized VS Lock
9．4．5　缩小锁的范围和粒度
9．4．6　线程分析工具
9．5　JVM调优
9．5．1　堆与栈
9．5．2　JVM内存的分代
9．5．3　GC分类
9．5．4　GC算法
9．5．5　分代GC
9．5．6　对象的引用
9．5．7　内存大小设置
9．5．8　内存调优工具
9．6　其他优化内容
9．6．1　避免使用反
9．6．2　对象池
9．6．3　缓冲区队列
9．6．4　使用直接内存
9．6．5　缓存其他对象
9．6．6　协调与平衡
10章　服务治理
10．1　服务治理概述
10．1．1　什么是服务治理
10．1．2　服务治理架构
10．1．3　服务治理接口
10．2　服务的定义
10．2．1　服务识别
10．2．2　接口定义
10．2．3　版本管理
10．2．4　协议适配
10．2．5　服务设计
10．2．6　服务的实现
10．2．7　依赖关系管理
10．3　服务的部署
10．3．1　服务的部署方式
10．3．2　自动化部署
10．3．3　服务的热部署
10．4　注册与发现
10．4．1　WSDL与UDDI
10．4．2　ZooKeeper的方案
10．4．3　Eureka的方案
10．4．4　Consul的方案
10．4．5　etcd的方案
10．4．6　注册中心集成方案
10．5　服务的控制
10．5．1　服务状态
10．5．2　服务控制
10．5．3　服务开关
10．5．4　服务模拟
10．5．5　黑白名单
10．5．6　“踢除”服务提供者
10．6　监控与限流
10．6．1　TPS监控与限流
10．6．2　响应时间的监控
10．6．3　调用链的监控
10．6．4　资源监控