| 作者 |
| 尼恩 汪文君 |
| 丛书名 |
| 出版社 |
| 机械工业出版社 |
| ISBN |
| 9782104251412 |
| 简要 |
| 简介 |
| 内容简介书籍计算机书籍 ---------------------------8080137 - Java高并发核心编程 卷2：多线程、锁、JMM、JUC、高并发设计模式--------------------------- 本书聚焦Java并发编程基础知识，介绍了Java多线程、线程池、内置锁、JMM、CAS、JUC、高并发设计模式等并发编程方面的核心原理和实战知识。 本书共分为10章。第1~2章浅显易懂地剖析多线程、线程池的核心原理和实战使用，揭秘线程安全问题和Java内置锁的核心原理；第3~4章细致地讲解CAS原理与JUC原子类、JMM的核心原理，揭秘CAS操作的弊端和两类规避措施、解密Java如何内存可见性和volatile关键字的底层知识；第5章细致地介绍JUC显示锁的原理和各种显示锁的使用；第6章图文并茂、深入浅出地阐述JUC高并发的基础设施：AQS抽象同步器核心原理；第7章介绍JUC容器类；第8~10章介绍常见的Java高并发设计模式的原理和使用。 ---------------------------8079752 - Java高并发核心编程 卷1：NIO、Netty、Redis、ZooKeeper--------------------------- 本书从操作系统底层的IO原理入手，同时提供高性能开发的实战案例，是一本Java高并发编程的基础原理和实战图书。 本书共分为15章。第1~4章为高并发基础，浅显易懂地剖析高并发IO的底层原理，细致地讲解Reactor高性能模式，图文并茂地介绍Java异步回调模式。这些原理方面的基础知识非常重要，会为读者打下坚实的基础，也是日常开发Java后台应用时解决实际问题的金钥匙。第5~8章为Netty原理和实战，是本书的重中之重，主要介绍高性能通信框架Netty、Netty的重要组件、单体IM的实战设计和模块实现。第9~12章从TCP、HTTP入手，介绍客户端与服务端、服务端与服务端之间的高性能HTTP通信和WebSocket通信。第13~15章对ZooKeeper、Curator API、Redis、Jedis API的使用进行详尽的说明，以提升读者设计和开发高并发、可扩展系统的能力。 ---------------------------8010626 - Java高并发编程详解：多线程与架构设计--------------------------- . 本书主要包含四个部分： 部分主要阐述Thread的基础知识，详细介绍线程的API使用、线程安全、线程间数据通信，以及如何保护共享资源等内容，它是深入学习多线程内容的基础。 第二部分引入了ClassLoader，这是因为ClassLoader与线程不无关系，我们可以通过synchronized关键字，或者Lock等显式锁的方式在代码的编写阶段对共享资源进行数据一致性保护，那么一个Class在完成初始化的整个过程到后在方法区（JDK8 以后在元数据空间）其数据结构是怎样确保数据一致性的呢？这就需要对ClassLoader有一个比较全面的认识和了解。 第三部分详细、深入地介绍volatile关键字的语义，volatile关键字在Java中非常重要，可以说它奠定了Java核心并发包的高效运行，在这一部分中，我们通过实例展示了如何使用volatile关键字以及非常详细地介绍了Java内存模型等知识。 本书的第四部分，站在程序架构设计的角度深入讲解了如何设计高效灵活的多线程应用程序，这一部分长达15个章节，其重要程度可见一斑。 |
| 目录 |
| [套装书具体书目] 8010626 - Java高并发编程详解：多线程与架构设计 - 9787111599937 - 机械工业出版社 - 定价 89 8079752 - Java高并发核心编程 卷1：NIO、Netty、Redis、ZooKeeper - 9787111677581 - 机械工业出版社 - 定价 149 8080137 - Java高并发核心编程 卷2：多线程、锁、JMM、JUC、高并发设计模式 - 9787111679882 - 机械工业出版社 - 定价 129 ---------------------------8080137 - Java高并发核心编程 卷2：多线程、锁、JMM、JUC、高并发设计模式--------------------------- 前言 自序 第1章 多线程原理与实战 1 1.1 两个技术面试故事 1 1.2 无处不在的进程和线程 2 1.2.1 进程的基本原理 3 1.2.2 线程的基本原理 5 1.2.3 进程与线程的区别 8 1.3 创建线程的4种方法 8 1.3.1 Thread类详解 8 1.3.2 创建一个空线程 10 1.3.3 线程创建方法一：继承Thread类创建线程类 12 1.3.4 线程创建方法二：实现Runnable接口创建线程目标类 13 1.3.5 优雅创建Runnable线程目标类的两种方式 16 1.3.6 通过实现Runnable接口的方式创建线程目标类的优缺点 18 1.3.7 线程创建方法三：使用Callable和FutureTask创建线程 23 1.3.8 线程创建方法四：通过线程池创建线程 28 1.4 线程的核心原理 31 1.4.1 线程的调度与时间片 31 1.4.2 线程的优先级 32 1.4.3 线程的生命周期 35 1.4.4 一个线程状态的简单演示案例 37 1.4.5 使用Jstack工具查看线程状态 40 1.5 线程的基本操作 41 1.5.1 线程名称的设置和获取 41 1.5.2 线程的sleep操作 43 1.5.3 线程的interrupt操作 45 1.5.4 线程的join操作 48 1.5.5 线程的yield操作 53 1.5.6 线程的daemon操作 55 1.5.7 线程状态总结 61 1.6 线程池原理与实战 62 1.6.1 JUC的线程池架构 63 1.6.2 Executors的4种快捷创建线程池的方法 65 1.6.3 线程池的标准创建方式 72 1.6.4 向线程池提交任务的两种方式 73 1.6.5 线程池的任务调度流程 77 1.6.6 ThreadFactory（线程工厂） 79 1.6.7 任务阻塞队列 81 1.6.8 调度器的钩子方法 82 1.6.9 线程池的拒绝策略 84 1.6.10 线程池的优雅关闭 87 1.6.11 Executors快捷创建线程池的潜在问题 93 1.7 确定线程池的线程数 97 1.7.1 按照任务类型对线程池进行分类 97 1.7.2 为IO密集型任务确定线程数 98 1.7.3 为CPU密集型任务确定线程数 100 1.7.4 为混合型任务确定线程数 101 1.8 ThreadLocal原理与实战 104 1.8.1 ThreadLocal的基本使用 104 1.8.2 ThreadLocal的使用场景 107 1.8.3 使用ThreadLocal进行线程隔离 108 1.8.4 使用ThreadLocal进行跨函数数据传递 109 1.8.5 ThreadLocal内部结构演进 110 1.8.6 ThreadLocal源码分析 111 1.8.7 ThreadLocalMap源码分析 114 1.8.8 ThreadLocal综合使用案例 119 第2章 Java内置锁的核心原理 123 2.1 线程安全问题 123 2.1.1 自增运算不是线程安全的 123 2.1.2 临界区资源与临界区代码段 126 2.2 synchronized关键字 127 2.2.1 synchronized同步方法 127 2.2.2 synchronized同步块 128 2.2.3 静态的同步方法 130 2.3 生产者-消费者问题 131 2.3.1 生产者-消费者模式 131 2.3.2 一个线程不安全的实现版本 132 2.3.3 一个线程安全的实现版本 139 2.4 Java对象结构与内置锁 140 2.4.1 Java对象结构 141 2.4.2 Mark Word的结构信息 143 2.4.3 使用JOL工具查看对象的布局 145 2.4.4 大小端问题 149 2.4.5 无锁、偏向锁、轻量级锁和重量级锁 150 2.5 偏向锁的原理与实战 152 2.5.1 偏向锁的核心原理 152 2.5.2 偏向锁的演示案例 152 2.5.3 偏向锁的膨胀和撤销 156 2.6 轻量级锁的原理与实战 157 2.6.1 轻量级锁的核心原理 157 2.6.2 轻量级锁的演示案例 158 2.6.3 轻量级锁的分类 161 2.6.4 轻量级锁的膨胀 162 2.7 重量级锁的原理与实战 162 2.7.1 重量级锁的核心原理 162 2.7.2 重量级锁的开销 165 2.7.3 重量级锁的演示案例 166 2.8 偏向锁、轻量级锁与重量级锁的对比 169 2.9 线程间通信 170 2.9.1 线程间通信的定义 170 2.9.2 低效的线程轮询 170 2.9.3 wait方法和notify方法的原理 171 2.9.4 “等待-通知”通信模式演示案例 174 2.9.5 生产者-消费者之间的线程间通信 177 2.9.6 需要在synchronized同步块的内部使用wait和notify 180 第3章 CAS原理与JUC原子类 182 3.1 什么是CAS 182 3.1.1 Unsafe类中的CAS方法 182 3.1.2 使用CAS进行无锁编程 185 3.1.3 使用无锁编程实现轻量级安全自增 186 3.1.4 字段偏移量的计算 189 3.2 JUC原子类 191 3.2.1 JUC中的Atomic原子操作包 191 3.2.2 基础原子类AtomicInteger 192 3.2.3 数组原子类AtomicIntegerArray 194 3.2.4 AtomicInteger线程安全原理 195 3.3 对象操作的原子性 198 3.3.1 引用类型原子类 198 3.3.2 属性更新原子类 200 3.4 ABA问题 201 3.4.1 了解ABA问题 201 3.4.2 ABA问题解决方案 203 3.4.3 使用AtomicStampedReference解决ABA问题 203 3.4.4 使用AtomicMarkableReference解决ABA问题 205 3.5 提升高并发场景下CAS操作的性能 207 3.5.1 以空间换时间：LongAdder 208 3.5.2 LongAdder的原理 211 3.6 CAS在JDK中的广泛应用 218 3.6.1 CAS操作的弊端和规避措施 218 3.6.2 CAS操作在JDK中的应用 219 第4章 可见性与有序性的原理 220 4.1 CPU物理缓存结构 220 4.2 并发编程的三大问题 222 4.2.1 原子性问题 222 4.2.2 可见性问题 223 4.2.3 有序性问题 224 4.3 硬件层的MESI协议原理 227 4.3.1 总线锁和缓存锁 228 4.3.2 MSI协议 230 4.3.3 MESI协议及RFO请求 230 4.3.4 volatile的原理 234 4.4 有序性与内存屏障 237 4.4.1 重排序 237 4.4.2 As-if-Serial规则 238 4.4.3 硬件层面的内存屏障 240 4.5 JMM详解 242 4.5.1 什么是Java内存模型 243 4.5.2 JMM与JVM物理内存的区别 244 4.5.3 JMM的8个操作 246 4.5.4 JMM如何解决有序性问题 248 4.5.5 volatile语义中的内存屏障 250 4.6 Happens-Before规则 251 4.6.1 Happens-Before规则介绍 252 4.6.2 规则1：顺序性规则 252 4.6.3 规则2：volatile规则 252 4.6.4 规则3：传递性规则 255 4.6.5 规则4：监视锁规则 255 4.6.6 规则5：start()规则 256 4.6.7 规则6：join()规则 257 4.7 volatile不具备原子性 258 4.7.1 volatile变量的自增实例 258 4.7.2 volatile变量的复合操作不具备原子性的原理 260 第5章 JUC显式锁的原理与实战 262 5.1 显式锁 262 5.1.1 显式锁Lock接口 263 5.1.2 可重入锁ReentrantLock 264 5.1.3 使用显式锁的模板代码 267 5.1.4 基于显式锁进行“等待-通知”方式的线程间通信 269 5.1.5 LockSupport 273 5.1.6 显式锁的分类 276 5.2 悲观锁和乐观锁 279 5.2.1 悲观锁存在的问题 279 5.2.2 通过CAS实现乐观锁 279 5.2.3 不可重入的自旋锁 280 5.2.4 可重入的自旋锁 281 5.2.5 CAS可能导致“总线风暴” 283 5.2.6 CLH自旋锁 285 5.3 公平锁与非公平锁 293 5.3.1 非公平锁实战 293 5.3.2 公平锁实战 295 5.4 可中断锁与不可中断锁 296 5.4.1 锁的可中断抢占 296 5.4.2 死锁的监测与中断 298 5.5 共享锁与独占锁 302 5.5.1 独占锁 302 5.5.2 共享锁Semaphore 302 5.5.3 共享锁CountDownLatch 306 5.6 读写锁 307 5.6.1 读写锁ReentrantReadWriteLock 308 5.6.2 锁的升级与降级 310 5.6.3 StampedLock 312 第6章 AQS抽象同步器的核心原理 316 6.1 锁与队列的关系 316 6.2 AQS的核心成员 318 6.2.1 状态标志位 318 6.2.2 队列节点类 319 6.2.3 FIFO双向同步队列 321 6.2.4 JUC显式锁与AQS的关系 322 6.2.5 ReentrantLock与AQS的组合关系 322 6.3 AQS中的模板模式 325 6.3.1 模板模式 325 6.3.2 一个模板模式的参考实现 326 6.3.3 AQS的模板流程 329 6.3.4 AQS中的钩子方法 329 6.4 通过AQS实现一把简单的独占锁 331 6.4.1 简单的独占锁的UML类图 331 6.4.2 简单的独占锁的实现 331 6.4.3 SimpleMockLock测试用例 333 6.5 AQS锁抢占的原理 335 6.5.1 显式锁抢占的总体流程 335 6.5.2 AQS模板方法：acquire(arg) 336 6.5.3 钩子实现：tryAcquire(arg) 336 6.5.4 直接入队：addWaiter 337 6.5.5 自旋入队：enq 338 6.5.6 自旋抢占：acquireQueued() 339 6.5.7 挂起预判：shouldParkAfterFailedAcquire() 340 6.5.8 线程挂起：parkAndCheckInterrupt() 342 6.6 AQS的两个关键点：节点的入队和出队 343 6.6.1 节点的自旋入队 343 6.6.2 节点的出队 343 6.7 AQS锁释放的原理 345 6.7.1 SimpleMockLock独占锁的释放流程 345 6.7.2 AQS模板方法：release() 345 6.7.3 钩子实现：tryRelease() 346 6.7.4 唤醒后继：unparkSuccessor() 346 6.8 ReentrantLock的抢锁流程 347 6.8.1 ReentrantLock非公平锁的抢占流程 347 6.8.2 非公平锁的同步器子类 348 6.8.3 非公平抢占的钩子方法：tryAcquire(arg) 349 6.8.4 ReentrantLock公平锁的抢占流程 350 6.8.5 公平锁的同步器子类 350 6.8.6 公平抢占的钩子方法：tryAcquire(arg) 351 6.8.7 是否有后继节点的判断 351 6.9 AQS条件队列 352 6.9.1 Condition基本原理 352 6.9.2 await()等待方法原理 353 6.9.3 signal()唤醒方法原理 355 6.10 AQS的实际应用 356 第7章 JUC容器类 358 7.1 线程安全的同步容器类 358 7.2 JUC高并发容器 360 7.3 CopyOnWriteArrayList 362 7.3.1 CopyOnWriteArrayList的使用 362 7.3.2 CopyOnWriteArrayList的原理 364 7.3.3 CopyOnWriteArrayList 读取操作 366 7.3.4 CopyOnWriteArrayList写入操作 366 7.3.5 CopyOnWriteArrayList的迭代器实现 367 7.4 BlockingQueue 368 7.4.1 BlockingQueue的特点 368 7.4.2 阻塞队列的常用方法 368 7.4.3 常见的BlockingQueue 370 7.4.4 ArrayBlockingQueue的基本使用 372 7.4.5 ArrayBlockingQueue构造器和成员 374 7.4.6 非阻塞式添加元素：add()、offer()方法的原理 376 7.4.7 阻塞式添加元素：put()方法的原理 378 7.4.8 非阻塞式删除元素：poll()方法的原理 380 7.4.9 阻塞式删除元素：take()方法的原理 381 7.4.10 peek()直接返回当前队列的头元素 382 7.5 ConcurrentHashMap 383 7.5.1 HashMap和HashTable的问题 383 7.5.2 JDK 1.7版本ConcurrentHashMap的结构 384 7.5.3 JDK 1.7版本ConcurrentHashMap的核心原理 385 7.5.4 JDK 1.8版本ConcurrentHashMap的结构 393 7.5.5 JDK 1.8版本ConcurrentHashMap的核心原理 395 7.5.6 JDK 1.8版本ConcurrentHashMap的核心源码 398 第8章 高并发设计模式 402 8.1 线程安全的单例模式 402 8.1.1 从饿汉式单例到懒汉式单例 402 8.1.2 使用内置锁保护懒汉式单例 404 8.1.3 双重检查锁单例模式 404 8.1.4 使用双重检查锁+volatile 405 8.1.5 使用静态内部类实现懒汉式单例模式 406 8.2 Master-Worker模式 407 8.2.1 Master-Worker模式的参考实现 408 8.2.2 Netty中Master-Worker模式的实现 413 8.2.3 Nginx中Master-Worker模式的实现 414 8.3 ForkJoin模式 415 8.3.1 ForkJoin模式的原理 415 8.3.2 ForkJoin框架 416 8.3.3 ForkJoin框架使用实战 416 8.3.4 ForkJoin框架的核心API 419 8.3.5 工作窃取算法 421 8.3.6 ForkJoin框架的原理 423 8.4 生产者-消费者模式 423 8.5 Future模式 424 第9章 高并发核心模式之异步回调模式 426 9.1 从泡茶的案例讲起 426 9.2 join：异步阻塞之闷葫芦 427 9.2.1 线程的合并流程 427 9.2.2 调用join()实现异步泡茶喝 427 9.2.3 join()方法详解 429 9.3 FutureTask：异步调用之重武器 430 9.3.1 通过FutureTask获取异步执行结果的步骤 431 9.3.2 使用FutureTask实现异步泡茶喝 431 9.4 异步回调与主动调用 434 9.5 Guava的异步回调模式 435 9.5.1 详解FutureCallback 435 9.5.2 详解ListenableFuture 436 9.5.3 ListenableFuture异步任务 437 9.5.4 使用Guava实现泡茶喝的实例 438 9.5.5 Guava异步回调和Java异步调用的区别 442 9.6 Netty的异步回调模式 442 9.6.1 GenericFutureListener接口详解 443 9.6.2 Netty的Future接口详解 443 9.6.3 ChannelFuture的使用 444 9.6.4 Netty的出站和入站异步回调 444 9.7 异步回调模式小结 445 第10章 CompletableFuture异步回调 446 10.1 CompletableFuture详解 446 10.1.1 CompletableFuture的UML类关系 446 10.1.2 CompletionStage接口 447 10.1.3 使用runAsync和supplyAsync创建子任务 448 10.1.4 设置子任务回调钩子 449 10.1.5 调用handle()方法统一处理异常和结果 451 10.1.6 线程池的使用 452 10.2 异步任务的串行执行 453 10.2.1 thenApply()方法 453 10.2.2 thenRun()方法 455 10.2.3 thenAccept()方法 455 10.2.4 thenCompose()方法 456 10.2.5 4个任务串行方法的区别 458 10.3 异步任务的合并执行 458 10.3.1 thenCombine()方法 458 10.3.2 runAfterBoth()方法 460 10.3.3 thenAcceptBoth()方法 461 10.3.4 allOf()等待所有的任务结束 462 10.4 异步任务的选择执行 463 10.4.1 applyToEither()方法 463 10.4.2 runAfterEither()方法 465 10.4.3 acceptEither()方法 465 10.5 CompletableFuture的综合案例 466 10.5.1 使用CompletableFuture实现泡茶喝实例 466 10.5.2 使用CompletableFuture进行多个RPC调用 468 10.5.3 使用RxJava模拟RPC异步回调 469 ---------------------------8079752 - Java高并发核心编程 卷1：NIO、Netty、Redis、ZooKeeper--------------------------- 前言 自序 第1章 高并发时代的必备技能 1 1.1 Netty为何这么火 1 1.1.1 Netty火热的程度 1 1.1.2 Netty是面试的必杀器 2 1.2 高并发利器Redis 2 1.2.1 什么是Redis 2 1.2.2 Redis成为缓存事实标准的原因 3 1.3 分布式利器ZooKeeper 3 1.3.1 什么是ZooKeeper 3 1.3.2 ZooKeeper的优势 4 1.4 高性能HTTP通信技术 4 1.4.1 十万级以上高并发场景中的高并发HTTP通信技术 5 1.4.2 微服务之间的高并发RPC技术 6 1.5 高并发IM的综合实战 7 1.5.1 高并发IM的学习价值 8 1.5.2 庞大的应用场景 8 第2章 高并发IO的底层原理 10 2.1 IO读写的基本原理 10 2.1.1 内核缓冲区与进程缓冲区 11 2.1.2 典型的系统调用流程 11 2.2 四种主要的IO模型 13 2.2.1 同步阻塞IO 14 2.2.2 同步非阻塞IO 15 2.2.3 IO多路复用 16 2.2.4 异步IO 17 2.3 通过合理配置来支持百万级并发连接 18 第3章 Java NIO核心详解 21 3.1 Java NIO简介 21 3.1.1 NIO和OIO的对比 21 3.1.2 通道 22 3.1.3 选择器 22 3.1.4 缓冲区 23 3.2 详解NIO Buffer类及其属性 23 3.2.1 Buffer类 23 3.2.2 Buffer类的重要属性 23 3.3 详解NIO Buffer类的重要方法 26 3.3.1 allocate() 26 3.3.2 put() 27 3.3.3 flip() 27 3.3.4 get() 29 3.3.5 rewind() 30 3.3.6 mark()和reset() 32 3.3.7 clear() 33 3.3.8 使用Buffer类的基本步骤 34 3.4 详解NIO Channel类 34 3.4.1 FileChannel 35 3.4.2 使用FileChannel完成文件复制的实战案例 37 3.4.3 SocketChannel 39 3.4.4 使用SocketChannel发送文件的实战案例 41 3.4.5 DatagramChannel 43 3.4.6 使用DatagramChannel发送数据的实战案例 45 3.5 详解NIO Selector 47 3.5.1 选择器与注册 47 3.5.2 SelectableChannel 48 3.5.3 SelectionKey 48 3.5.4 选择器使用流程 48 3.5.5 使用NIO实现Discard服务器的实战案例 50 3.5.6 使用SocketChannel在服务端接收文件的实战案例 53 第4章 鼎鼎大名的Reactor模式 59 4.1 Reactor模式的重要性 59 4.1.1 为什么首先学习Reactor模式 59 4.1.2 Reactor模式简介 60 4.1.3 多线程OIO的致命缺陷 60 4.2 单线程Reactor模式 62 4.2.1 什么是单线程Reactor 62 4.2.2 单线程Reactor的参考代码 63 4.2.3 单线程Reactor模式的EchoServer的实战案例 66 4.2.4 单线程Reactor模式的缺点 69 4.3 多线程Reactor模式 69 4.3.1 多线程版本的Reactor模式演进 69 4.3.2 多线程版本Reactor的实战案例 69 4.3.3 多线程版本Handler的实战案例 72 4.4 Reactor模式的优缺点 74 第5章 Netty核心原理与基础实战 76 5.1 第一个Netty实战案例DiscardServer 76 5.1.1 创建第一个Netty项目 76 5.1.2 第一个Netty服务端程序 77 5.1.3 业务处理器NettyDiscardHandler 79 5.1.4 运行NettyDiscardServer 80 5.2 解密Netty中的Reactor模式 80 5.2.1 回顾Reactor模式中IO事件的处理流程 81 5.2.2 Netty中的Channel 81 5.2.3 Netty中的Reactor 82 5.2.4 Netty中的Handler 83 5.2.5 Netty中的Pipeline 84 5.3 详解Bootstrap 86 5.3.1 父子通道 86 5.3.2 EventLoopGroup 87 5.3.3 Bootstrap启动流程 88 5.3.4 ChannelOption 91 5.4 详解Channel 93 5.4.1 Channel的主要成员和方法 93 5.4.2 EmbeddedChannel 94 5.5 详解Handler 95 5.5.1 ChannelInboundHandler入站处理器 96 5.5.2 ChannelOutboundHandler出站处理器 97 5.5.3 ChannelInitializer通道初始化处理器 99 5.5.4 ChannelInboundHandler的生命周期的实战案例 99 5.6 详解Pipeline 103 5.6.1 Pipeline入站处理流程 103 5.6.2 Pipeline出站处理流程 104 5.6.3 ChannelHandlerContext 106 5.6.4 HeadContext与TailContext 107 5.6.5 Pipeline入站和出站的双向链接操作 109 5.6.6 截断流水线的入站处理传播过程 112 5.6.7 在流水线上热插拔Handler 114 5.7 详解ByteBuf 117 5.7.1 ByteBuf的优势 117 5.7.2 ByteBuf的组成部分 117 5.7.3 ByteBuf的重要属性 118 5.7.4 ByteBuf的方法 118 5.7.5 ByteBuf基本使用的实战案例 120 5.7.6 ByteBuf的引用计数 122 5.7.7 ByteBuf的分配器 124 5.7.8 ByteBuf缓冲区的类型 126 5.7.9 两类ByteBuf使用的实战案例 127 5.7.10 ByteBuf的自动创建与自动释放 130 5.7.11 ByteBuf浅层复制的高级使用方式 136 5.8 Netty的零拷贝 138 5.8.1 通过CompositeByteBuf实现零拷贝 139 5.8.2 通过wrap操作实现零拷贝 141 5.9 EchoServer的实战案例 142 5.9.1 NettyEchoServer 142 5.9.2 NettyEchoServerHandler 143 5.9.3 NettyEchoClient 144 5.9.4 NettyEchoClientHandler 146 第6章 Decoder与Encoder核心组件 148 6.1 Decoder原理与实战 148 6.1.1 ByteToMessageDecoder解码器处理流程 148 6.1.2 自定义Byte2IntegerDecoder整数解码器 149 6.1.3 ReplayingDecoder解码器 152 6.1.4 整数的分包解码器的实战案例 153 6.1.5 字符串的分包解码器的实战案例 156 6.1.6 MessageToMessageDecoder解码器 161 6.2 常用的内置Decoder 161 6.2.1 LineBasedFrameDecoder解码器 162 6.2.2 DelimiterBasedFrameDecoder解码器 163 6.2.3 LengthFieldBasedFrameDecoder解码器 164 6.2.4 多字段Head-Content协议数据包解析的实战案例 167 6.3 Encoder原理与实战 170 6.3.1 MessageToByteEncoder编码器 170 6.3.2 MessageToMessageEncoder编码器 171 6.4 解码器和编码器的结合 173 6.4.1 ByteToMessageCodec编解码器 173 6.4.2 CombinedChannelDuplexHandler组合器 174 第7章 序列化与反序列化：JSON和Protobuf 176 7.1 详解粘包和拆包 177 7.1.1 半包问题的实战案例 177 7.1.2 什么是半包问题 179 7.1.3 半包问题的根因分析 179 7.2 使用JSON协议通信 180 7.2.1 JSON的核心优势 180 7.2.2 JSON序列化与反序列化开源库 181 7.2.3 JSON序列化与反序列化的实战案例 182 7.2.4 JSON传输的编码器和解码器 184 7.2.5 JSON传输的服务端的实战案例 185 7.2.6 JSON传输的客户端的实战案例 186 7.3 使用Protobuf协议通信 188 7.3.1 一个简单的proto文件的实战案例 188 7.3.2 通过控制台命令生成POJO和Builder 189 7.3.3 通过Maven插件生成POJO和Builder 190 7.3.4 Protobuf序列化与反序列化的实战案例 191 7.4 Protobuf编解码的实战案例 194 7.4.1 Netty内置的Protobuf基础编码器/解码器 194 7.4.2 Protobuf传输的服务端的实战案例 195 7.4.3 Protobuf传输的客户端的实战案例 197 7.5 详解Protobuf协议语法 198 7.5.1 proto文件的头部声明 199 7.5.2 Protobuf的消息结构体与消息字段 200 7.5.3 Protobuf字段的数据类型 201 7.5.4 proto文件的其他语法规范 202 第8章 基于Netty单体IM系统的开发实战 204 8.1 自定义Protobuf编解码器 204 8.1.1 自定义Protobuf编码器 205 8.1.2 自定义Protobuf解码器 206 8.1.3 IM系统中Protobuf消息格式的设计 207 8.2 IM的登录流程 209 8.2.1 图解登录/响应流程的环节 209 8.2.2 客户端涉及的主要模块 210 8.2.3 服务端涉及的主要模块 210 8.3 客户端的登录处理的实战案例 211 8.3.1 LoginConsoleCommand和User POJO 212 8.3.2 LoginSender 213 8.3.3 ClientSession 216 8.3.4 LoginResponseHandler 218 8.3.5 客户端流水线的装配 219 8.4 服务端的登录响应的实战案例 220 8.4.1 服务端流水线的装配 220 8.4.2 LoginRequestHandler 221 8.4.3 LoginProcesser 223 8.4.4 EventLoop线程和业务线程相互隔离 224 8.5 详解Session服务器会话 227 8.5.1 通道的容器属性 227 8.5.2 ServerSession服务端会话类 229 8.5.3 SessionMap会话管理器 230 8.6 点对点单聊的实战案例 230 8.6.1 单聊的端到端流程 231 8.6.2 客户端的ChatConsoleCommand收集聊天内容 231 8.6.3 客户端的CommandController发送POJO 232 8.6.4 服务端的ChatRedirectHandler进行消息转发 233 8.6.5 服务端的ChatRedirectProcesser进行异步消息转发 234 8.6.6 客户端的ChatMsgHandler聊天消息处理器 235 8.7 详解心跳检测 236 8.7.1 网络连接的假死现象 236 8.7.2 服务端的空闲检测 237 8.7.3 客户端的心跳发送 238 第9章 HTTP原理与Web服务器实战 241 9.1 高性能Web应用架构 241 9.1.1 十万级并发的Web应用架构 241 9.1.2 千万级高并发的Web应用架构 243 9.2 详解HTTP应用层协议 246 9.2.1 HTTP简介 247 9.2.2 HTTP的请求URL 248 9.2.3 HTTP的请求报文 248 9.2.4 HTTP的响应报文 251 9.2.5 HTTP中GET和POST的区别 254 9.3 HTTP的演进 254 9.3.1 HTTP的1.0版本 255 9.3.2 HTTP的1.1版本 258 9.3.3 HTTP的2.0版本 261 9.4 基于Netty实现简单的Web服务器 263 9.4.1 基于Netty的HTTP服务器演示实例 263 9.4.2 基于Netty的HTTP请求的处理流程 264 9.4.3 Netty内置的HTTP报文解码流程 266 9.4.4 基于Netty的HTTP响应编码流程 268 9.4.5 HttpEchoHandler回显业务处理器的实战案例 269 9.4.6 使用Postman发送多种类型的请求体 273 第10章 高并发HTTP通信的核心原理 278 10.1 需要进行HTTP连接复用的高并发场景 278 10.1.1 反向代理Nginx与Java Web应用服务之间的HTTP 高并发通信 278 10.1.2 微服务网关与微服务Provider实例之间的HTTP高并发通信 279 10.1.3 分布式微服务Provider实例之间的RPC的HTTP高并发通信 280 10.1.4 Java通过HTTP客户端访问REST接口服务的HTTP 高并发通信 280 10.2 详解传输层TCP 281 10.2.1 TCP/IP的分层模型 281 10.2.2 HTTP报文传输原理 283 10.2.3 TCP的报文格式 285 10.2.4 TCP的三次握手 288 10.2.5 TCP的四次挥手 290 10.2.6 三次握手、四次挥手的常见面试题 292 10.3 TCP连接状态的原理与实验 293 10.3.1 TCP/IP连接的11种状态 293 10.3.2 通过netstat指令查看连接状态 295 10.4 HTTP长连接原理 297 10.4.1 HTTP长连接和短连接 297 10.4.2 不同HTTP版本中的长连接选项 298 10.5 服务端HTTP长连接技术 299 10.5.1 应用服务器Tomcat的长连接配置 299 10.5.2 Nginx承担服务端角色时的长连接配置 302 10.5.3 服务端长连接设置的注意事项 304 10.6 客户端HTTP长连接技术原理与实验 306 10.6.1 HttpURLConnection短连接技术 306 10.6.2 HTTP短连接的通信实验 309 10.6.3 Apache HttpClient客户端的HTTP长连接技术 311 10.6.4 Apache HttpClient客户端长连接实验 319 10.6.5 Nginx承担客户端角色时的长连接技术 323 第11章 WebSocket原理与实战 326 11.1 WebSocket协议简介 326 11.1.1 Ajax短轮询和Long Poll长轮询的原理 327 11.1.2 WebSocket与HTTP之间的关系 327 11.2 WebSocket回显演示程序开发 328 11.2.1 WebSocket回显程序的客户端代码 328 11.2.2 WebSocket相关的Netty内置处理类 331 11.2.3 WebSocket的回显服务器 333 11.2.4 WebSocket的业务处理器 335 11.3 WebSocket协议通信的原理 337 11.3.1 抓取WebSocket协议的本机数据包 337 11.3.2 WebSocket 握手过程 338 11.3.3 WebSocket通信报文格式 341 第12章 SSL/TLS核心原理与实战 344 12.1 什么是SSL/TLS 344 12.1.1 SSL/TLS协议的版本演进 344 12.1.2 SSL/TLS协议的分层结构 346 12.2 加密算法原理与实战 347 12.2.1 哈希单向加密算法原理与实战 347 12.2.2 对称加密算法原理与实战 349 12.2.3 非对称加密算法原理与实战 351 12.2.4 数字签名原理与实战 356 12.3 SSL/TLS运行过程 361 12.3.1 SSL/TLS第一阶段握手 361 12.3.2 SSL/TLS第二阶段握手 363 12.3.3 SSL/TLS第三阶段握手 367 12.3.4 SSL/TLS第四阶段握手 369 12.4 详解Keytool工具 370 12.4.1 数字证书与身份识别 370 12.4.2 存储密钥与证书文件格式 373 12.4.3 使用Keytool工具管理密钥和证书 374 12.5 使用Java程序管理密钥与证书 377 12.5.1 使用Java操作数据证书所涉及的核心类 378 12.5.2 使用Java程序创建密钥与仓库 378 12.5.3 使用Java程序导出证书文件 383 12.5.4 使用Java程序将数字证书导入信任仓库 385 12.6 OIO通信中的SSL/TLS使用实战 389 12.6.1 JSSE安全套接字扩展核心类 390 12.6.2 JSSE安全套接字的创建过程 391 12.6.3 OIO安全通信的Echo服务端实战 393 12.6.4 OIO安全通信的Echo客户端实战 395 12.7 单向认证与双向认证 396 12.7.1 SSL/TLS 单向认证 396 12.7.2 使用证书信任管理器 399 12.7.3 SSL/TLS 双向认证 402 12.8 Netty通信中的SSL/TLS使用实战 405 12.8.1 Netty安全通信演示实例 405 12.8.2 Netty内置SSLEngine处理器详解 406 12.8.3 Netty的简单安全聊天器服务端程序 409 12.9 HTTPS协议安全通信实战 412 12.9.1 使用Netty实现HTTPS回显服务端程序 412 12.9.2 通过HttpsURLConnection发送HTTPS请求 414 12.9.3 HTTPS服务端与客户端的测试用例 415 第13章 ZooKeeper分布式协调 417 13.1 ZooKeeper伪集群安装和配置 417 13.1.1 创建数据和日志 417 13.1.2 创建myid文本文件 419 13.1.3 创建和修改配置文件 419 13.1.4 配置文件示例 421 13.1.5 启动ZooKeeper伪集群 422 13.2 使用ZooKeeper 进行分布式存储 423 13.2.1 详解ZooKeeper存储模型 424 13.2.2 zkCli客户端指令清单 424 13.3 ZooKeeper应用开发实战 426 13.3.1 ZkClient开源客户端 427 13.3.2 Curator开源客户端 427 13.3.3 准备Curator开发环境 428 13.3.4 创建Curator客户端实例 429 13.3.5 通过Curator创建节点 431 13.3.6 通过Curator读取节点 432 13.3.7 通过Curator更新节点 433 13.3.8 通过Curator删除节点 435 13.4 分布式命名服务实战 436 13.4.1 ID生成器 437 13.4.2 ZooKeeper分布式ID生成器的实战案例 438 13.4.3 集群节点的命名服务的实战案例 440 13.4.4 结合ZooKeeper实现SnowFlake ID算法 442 13.5 分布式事件监听的重点 447 13.5.1 Watcher标准的事件处理器 448 13.5.2 NodeCache节点缓存的监听 451 13.5.3 PathCache子节点监听 454 13.5.4 TreeCache节点树缓存 457 13.6 分布式锁原理与实战 461 13.6.1 公平锁和可重入锁的原理 461 13.6.2 ZooKeeper分布式锁的原理 463 13.6.3 分布式锁的基本流程 464 13.6.4 加锁的实现 465 13.6.5 释放锁的实现 471 13.6.6 分布式锁的使用 472 13.6.7 Curator的InterProcessMutex可重入锁 473 13.6.8 ZooKeeper分布式锁的优缺点 474 第14章 分布式缓存Redis实战 476 14.1 Redis入门 476 14.1.1 Redis的安装和配置 476 14.1.2 Redis客户端命令 479 14.1.3 Redis键的命名规范 480 14.2 Redis数据类型 481 14.2.1 String 481 14.2.2 List 482 14.2.3 Hash 484 14.2.4 Set 485 14.2.5 ZSet 486 14.3 Jedis基础编程的实战案例 487 14.3.1 Jedis操作String 488 14.3.2 Jedis操作List 490 14.3.3 Jedis操作Hash 491 14.3.4 Jedis操作Set 493 14.3.5 Jedis操作ZSet 494 14.4 JedisPool连接池的实战案例 497 14.4.1 JedisPool的配置 497 14.4.2 JedisPool的创建和预热 499 14.4.3 JedisPool的使用 501 14.5 使用spring-data-redis完成CRUD的实战案例 502 14.5.1 CRUD中应用缓存的场景 502 14.5.2 配置spring-redis.xml 504 14.5.3 RedisTemplate模板API 506 14.5.4 使用RedisTemplate模板API完成CRUD的实战案例 509 14.5.5 使用RedisCallback回调完成CRUD的实战案例 511 14.6 Spring的Redis缓存注解 513 14.6.1 使用Spring缓存注解完成CRUD的实战案例 514 14.6.2 spring-redis.xml中配置的调整 515 14.6.3 @CachePut和@Cacheable注解 517 14.6.4 @CacheEvict注解 518 14.6.5 @Caching组合注解 519 14.7 详解SpEL 520 14.7.1 SpEL运算符 521 14.7.2 缓存注解中的SpEL表达式 524 第15章 亿级高并发IM架构与实战 526 15.1 支撑亿级流量的高并发IM架构的理论基础 526 15.1.1 亿级流量的系统架构的开发实战 527 15.1.2 高并发架构的技术选型 527 15.1.3 详解IM消息的序列化协议选型 528 15.1.4 详解长连接和短连接 528 15.2 分布式IM的命名服务的实战案例 529 15.2.1 IM节点的POJO类 530 15.2.2 IM节点的ImWorker类 531 15.3 Worker集群的负载均衡的实战案例 534 15.3.1 ImLoadBalance负载均衡器 535 15.3.2 与WebGate的整合 537 15.4 即时通信消息的路由和转发的实战案例 538 15.4.1 IM路由器WorkerRouter 538 15.4.2 IM转发器PeerSender 541 15.5 在线用户统计的实战案例 543 15.5.1 Curator的分布式计数器 543 15.5.2 用户上线和下线的统计 545 ---------------------------8010626 - Java高并发编程详解：多线程与架构设计--------------------------- 推荐序一 推荐序二 推荐序三 推荐序四 前言 第一部分 多线程基础 第1章 快速认识线程 3 1.1 线程的介绍 3 1.2 快速创建并启动一个线程 3 1.2.1 尝试并行运行 4 1.2.2 并发运行交替输出 5 1.2.3 使用Jconsole观察线程 6 1.3 线程的生命周期详解 7 1.3.1 线程的NEW状态 8 1.3.2 线程的RUNNABLE状态 8 1.3.3 线程的 RUNNING状态 8 1.3.4 线程的BLOCKED状态 8 1.3.5 线程的TERMINATED状态 9 1.4 线程的start方法剖析：模板设计模式在Thread中的应用 9 1.4.1 Thread start方法源码分析以及注意事项 9 1.4.2 模板设计模式在Thread中的应用 11 1.4.3 Thread模拟营业大厅叫号机程序 13 1.5 Runnable接口的引入以及策略模式在Thread中的使用 16 1.5.1 Runnable的职责 16 1.5.2 策略模式在Thread中的应用 16 1.5.3 模拟营业大厅叫号机程序 18 1.6 本章总结 19 第2章 深入理解Thread构造函数 20 2.1 线程的命名 20 2.1.1 线程的默认命名 21 2.1.2 命名线程 21 2.1.3 修改线程的名字 22 2.2 线程的父子关系 22 2.3 Thread与ThreadGroup 23 2.4 Thread与Runnable 24 2.5 Thread与JVM虚拟机栈 25 2.5.1 Thread与Stacksize 25 2.5.2 JVM内存结构 27 2.5.3 Thread与虚拟机栈 30 2.6 守护线程 33 2.6.1 什么是守护线程 33 2.6.2 守护线程的作用 34 2.7 本章总结 34 第3章 Thread API的详细介绍 35 3.1 线程sleep 35 3.1.1 sleep方法介绍 35 3.1.2 使用TimeUnit替代Thread.sleep 36 3.2 线程yield 37 3.2.1 yield方法介绍 37 3.2.2 yield和sleep 37 3.3 设置线程的优先级 38 3.3.1 线程优先级介绍 38 3.3.2 线程优先级源码分析 39 3.3.3 关于优先级的一些总结 40 3.4 获取线程ID 40 3.5 获取当前线程 41 3.6 设置线程上下文类加载器 41 3.7 线程interrupt 42 3.7.1 interrupt 42 3.7.2 isInterrupted 43 3.7.3 interrupted 45 3.7.4 interrupt注意事项 46 3.8 线程join 47 3.8.1 线程join方法详解 48 3.8.2 join方法结合实战 50 3.9 如何关闭一个线程 53 3.9.1 正常关闭 54 3.9.2 异常退出 56 3.9.3 进程假死 56 3.10 本章总结 58 第4章 线程安全与数据同步 59 4.1 数据同步 59 4.1.1 数据不一致问题的引入 59 4.1.2 数据不一致问题原因分析 61 4.2 初识 synchronized关键字 62 4.2.1 什么是synchronized 63 4.2.2 synchronized关键字的用法 63 4.3 深入synchronized关键字 65 4.3.1 线程堆栈分析 65 4.3.2 JVM指令分析 67 4.3.3 使用synchronized需要注意的问题 70 4.4 This Monitor和Class Monitor的详细介绍 72 4.4.1 this monitor 72 4.4.2 class monitor 74 4.5 程序死锁的原因以及如何诊断 77 4.5.1 程序死锁 77 4.5.2 程序死锁举例 77 4.5.3 死锁诊断 80 4.6 本章总结 81 第5章 线程间通信 82 5.1 同步阻塞与异步非阻塞 82 5.1.1 同步阻塞消息处理 82 5.1.2 异步非阻塞消息处理 83 5.2 单线程间通信 84 5.2.1 初识wait和notify 84 5.2.2 wait和notify方法详解 87 5.2.3 关于wait和notify的注意事项 89 5.2.4 wait和sleep 90 5.3 多线程间通信 90 5.3.1 生产者消费者 90 5.3.2 线程休息室wait set 93 5.4 自定义显式锁BooleanLock 94 5.4.1 synchronized关键字的缺陷 94 5.4.2 显式锁BooleanLock 95 5.5 本章总结 104 第6章 ThreadGroup详细讲解 105 6.1 ThreadGroup与Thread 105 6.2 创建ThreadGroup 105 6.3 复制Thread数组和ThreadGroup数组 106 6.3.1 复制Thread数组 106 6.3.2 复制ThreadGroup数组 109 6.4 ThreadGroup操作 109 6.4.1 ThreadGroup的基本操作 110 6.4.2 ThreadGroup的interrupt 113 6.4.3 ThreadGroup的destroy 114 6.4.4 守护ThreadGroup 115 6.5 本章总结 116 第7章 Hook线程以及捕获线程执行异常 117 7.1 获取线程运行时异常 117 7.1.1 UncaughtExceptionHandler的介绍 117 7.1.2 UncaughtExceptionHandler实例 118 7.1.3 UncaughtExceptionHandler源码分析 119 7.2 注入钩子线程 121 7.2.1 Hook线程介绍 121 7.2.2 Hook线程实战 122 7.2.3 Hook线程应用场景以及注意事项 124 7.3 本章总结 124 第8章 线程池原理以及自定义线程池 125 8.1 线程池原理 125 8.2 线程池实现 126 8.2.1 线程池接口定义 127 8.2.2 线程池详细实现 131 8.3 线程池的应用 139 8.4 本章总结 142 第二部分 Java ClassLoader 第9章 类的加载过程 144 9.1 类的加载过程简介 144 9.2 类的主动使用和被动使用 145 9.3 类的加载过程详解 148 9.3.1 类的加载阶段 148 9.3.2 类的连接阶段 149 9.3.3 类的初始化阶段 154 9.4 本章总结 156 第10章 JVM类加载器 158 10.1 JVM内置三大类加载器 158 10.1.1 根类加载器介绍 159 10.1.2 扩展类加载器介绍 159 10.1.3 系统类加载器介绍 160 10.2 自定义类加载器 161 10.2.1 自定义类加载器，问候世界 161 10.2.2 双亲委托机制详细介绍 165 10.2.3 破坏双亲委托机制 167 10.2.4 类加载器命名空间、运行时包、类的卸载等 170 10.3 本章总结 175 第11章 线程上下文类加载器 177 11.1 为什么需要线程上下文类加载器 177 11.2 数据库驱动的初始化源码分析 178 11.3 本章总结 180 第三部分 深入理解volatile关键字 第12章 volatile关键字的介绍 182 12.1 初识volatile关键字 182 12.2 机器硬件CPU 184 12.2.1 CPU Cache模型 184 12.2.2 CPU缓存一致性问题 186 12.3 Java内存模型 187 12.4 本章总结 188 第13章 深入volatile关键字 189 13.1 并发编程的三个重要特性 189 13.1.1 原子性 189 13.1.2 可见性 190 13.1.3 有序性 190 13.2 JMM如何保证三大特性 191 13.2.1 JMM与原子性 192 13.2.2 JMM与可见性 193 13.2.3 JMM与有序性 194 13.3 volatile关键字深入解析 195 13.3.1 volatile关键字的语义 195 13.3.2 volatile的原理和实现机制 197 13.3.3 volatile的使用场景 198 13.3.4 volatile和synchronized 199 13.4 本章总结 200 第14章 7种单例设计模式的设计 201 14.1 饿汉式 201 14.2 懒汉式 202 14.3 懒汉式+同步方法 203 14.4 Double-Check 204 14.5 Volatile+Double-Check 206 14.6 Holder方式 206 14.7 枚举方式 207 14.8 本章总结 208 第四部分 多线程设计架构模式 第15章 监控任务的生命周期 212 15.1 场景描述 212 15.2 当观察者模式遇到Thread 212 15.2.1 接口定义 212 15.2.2 ObservableThread实现 215 15.3 本章总结 217 15.3.1 测试运行 217 15.3.2 关键点总结 219 第16章 Single Thread Execution设计模式 220 16.1 机场过安检 220 16.1.1 非线程安全 221 16.1.2 问题分析 223 16.1.3 线程安全 225 16.2 吃面问题 225 16.2.1 吃面引起的死锁 226 16.2.2 解决吃面引起的死锁问题 228 16.2.3 哲学家吃面 229 16.3 本章总结 230 第17章 读写锁分离设计模式 231 17.1 场景描述 231 17.2 读写分离程序设计 232 17.2.1 接口定义 232 17.2.2 程序实现 234 17.3 读写锁的使用 239 17.4 本章总结 242 第18章 不可变对象设计模式 244 18.1 线程安全性 244 18.2 不可变对象的设计 244 18.2.1 非线程安全的累加器 245 18.2.2 方法同步增加线程安全性 247 18.2.3 不可变的累加器对象设计 248 18.3 本章总结 249 第19章 Future设计模式 251 19.1 先给你一张凭据 251 19.2 Future设计模式实现 251 19.2.1 接口定义 252 19.2.2 程序实现 253 19.3 Future的使用以及技巧总结 256 19.4 增强FutureService使其支持回调 257 19.5 本章总结 258 第20章 Guarded Suspension设计模式 259 20.1 什么是Guarded Suspension设计模式 259 20.2 Guarded Suspension的示例 259 20.3 本章总结 261 第21章 线程上下文设计模式 262 21.1 什么是上下文 262 21.2 线程上下文设计 263 21.3 ThreadLocal详解 264 21.3.1 ThreadLocal的使用场景及注意事项 265 21.3.2 ThreadLocal的方法详解及源码分析 265 21.3.3 ThreadLocal的内存泄漏问题分析 270 21.4 使用ThreadLocal设计线程上下文 274 21.5 本章总结 276 第22章 Balking设计模式 277 22.1 什么是Balking设计 277 22.2 Balking模式之文档编辑 278 22.2.1 Document 278 22.2.2 AutoSaveThread 280 22.2.3 DocumentEditThread 281 22.3 本章总结 283 第23章 Latch设计模式 284 23.1 什么是Latch 284 23.2 CountDownLatch程序实现 285 23.2.1 无限等待的Latch 285 23.2.2 有超时设置的Latch 289 23.3 本章总结 291 第24章 Thread-Per-Message设计模式 293 24.1 什么是Thread-Per-Message模式 293 24.2 每个任务一个线程 293 24.3 多用户的网络聊天 296 24.3.1 服务端程序 296 24.3.2 响应客户端连接的Handler 297 24.3.3 聊天程序测试 299 24.4 本章总结 300 第25章 Two Phase Termination设计模式 301 25.1 什么是Two Phase Termination模式 301 25.2 Two Phase Termination的示例 302 25.2.1 线程停止的Two Phase Termination 302 25.2.2 进程关闭的Two Phase Termination 303 25.3 知识扩展 304 25.3.1 Strong Reference及LRUCache 304 25.3.2 Soft Reference及SoftLRUCache 308 25.3.3 Weak Reference 311 25.3.4 Phantom Reference 312 25.4 本章总结 314 第26章 Worker-Thread设计模式 315 26.1 什么是Worker-Thread模式 315 26.2 Worker-Thread模式实现 315 26.2.1 产品及组装说明书 316 26.2.2 流水线传送带 317 26.2.3 流水线工人 319 26.3 本章总结 320 26.3.1 产品流水线测试 320 26.3.2 Worker-Thread和Producer-Consumer 321 第27章 Active Objects设计模式 323 27.1 接受异步消息的主动对象 323 27.2 标准Active Objects模式设计 323 27.2.1 OrderService接口设计 325 27.2.2 OrderServiceImpl 详解 325 27.2.3 OrderServiceProxy详解 326 27.2.4 MethodMessage 328 27.2.5 ActiveMessageQueue 330 27.2.6 OrderServiceFactory及测试 332 27.3 通用Active Objects框架设计 333 27.3.1 ActiveMessage详解 334 27.3.2 @ActiveMethod 336 27.3.3 ActiveServiceFactory详解 337 27.3.4 ActiveMessageQueue及其他 339 27.4 本章总结 341 第28章 Event Bus设计模式 342 28.1 Event Bus设计 343 28.1.1 Bus接口详解 343 28.1.2 同步EventBus详解 345 28.1.3 异步EventBus详解 347 28.1.4 Subscriber注册表Registry详解 348 28.1.5 Event广播Dispatcher详解 350 28.1.6 其他类接口设计 353 28.1.7 Event Bus测试 355 28.2 Event Bus实战——监控变化 357 28.2.1 WatchService遇到EventBus 357 28.2.2 FileChangeEvent 359 28.2.3 监控变化 359 28.3 本章总结 360 第29章 Event Driven设计模式 361 29.1 Event-Driven Architecture基础 361 29.1.1 Events 361 29.1.2 Event Handlers 362 29.1.3 Event Loop 363 29.2 开发一个Event-Driven框架 364 29.2.1 同步EDA框架设计 364 29.2.2 异步EDA框架设计 370 29.3 Event-Driven的使用 375 29.3.1 Chat Event 375 29.3.2 Chat Channel（Handler） 376 29.3.3 Chat User线程 377 29.4 本章总结 379 |