实战Java高并发程序设计（第2版）

理论结合实战。本书注重实战，书中重要的知识点都安排了代码实例，帮助读者理解。同时也不忘记对系统的内部实现原理进行深度剖析。
通俗易懂。尽量避免采用过于理论的描述方式，简单的白话文风格贯穿全书，配图基本上为手工绘制，降低了理解难度，并尽量做到读者在阅读过程中少盲点、无盲点。
读者评价：脉络清晰，查阅方便，讲解到位，通俗易懂，多线程和高并发专业必备。

在单核CPU时代，单任务在一个时间点只能执行单一程序，随着多核CPU的发展，并行程序开发变得尤为重要。

葛一鸣：炼数成金特约讲师，国家认证系统分析师，获得Oracle OCP认证。长期从事Java软件开发工作，对Java程序设计、JVM有深入研究，对设计模式、人工智能、神经网络、数据挖掘等技术有浓厚兴趣，著有《实战Java虚拟机》一书，目前在Dataguru开设多门课程，包括Java并发、JVM、Git等。

第1章　走入并行世界 1
1.1　何去何从的并行计算 1
1.1.1　忘掉那该死的并行 2
1.1.2　可怕的现实：摩尔定律的失效 4
1.1.3　柳暗花明：不断地前进 5
1.1.4　光明或是黑暗 6
1.2　你必须知道的几个概念 7
1.2.1　同步（Synchronous）和异步（Asynchronous） 7
1.2.2　并发（Concurrency）和并行（Parallelism） 8
1.2.3　临界区 9
1.2.4　阻塞（Blocking）和非阻塞（Non-Blocking） 9
1.2.5　死锁（Deadlock）、饥饿（Starvation）和活锁（Livelock） 10
1.3　并发级别 11
1.3.1　阻塞 11
1.3.2　无饥饿（Starvation-Free） 11
1.3.3　无障碍（Obstruction-Free） 12
1.3.4　无锁（Lock-Free） 13
1.3.5　无等待（Wait-Free） 13
1.4　有关并行的两个重要定律 14
1.4.1　Amdahl定律 14
1.4.2　Gustafson定律 16
1.4.3　是否相互矛盾 17
1.5　回到Java：JMM 18
1.5.1　原子性（Atomicity） 18
1.5.2　可见性（Visibility） 20
1.5.3　有序性（Ordering） 22
1.5.4　哪些指令不能重排：Happen-Before规则 27
第2章　Java并行程序基础 29
2.1　有关线程你必须知道的事 29
2.2　初始线程：线程的基本操作 32
2.2.1　新建线程 32
2.2.2　终止线程 34
2.2.3　线程中断 38
2.2.4　等待（wait）和通知（notify） 41
2.2.5　挂起（suspend）和继续执行（resume）线程 45
2.2.6　等待线程结束（join）和谦让（yeild） 49
2.3　volatile与Java内存模型（JMM） 50
2.4　分门别类的管理：线程组 53
2.5　驻守后台：守护线程（Daemon） 54
2.6　先做重要的事：线程优先级 56
2.7　线程安全的概念与关键字synchronized 57
2.8　程序中的幽灵：隐蔽的错误 61
2.8.1　无提示的错误案例 62
2.8.2　并发下的ArrayList 63
2.8.3　并发下诡异的HashMap 64
2.8.4　初学者常见的问题：错误的加锁 67
第3章　JDK并发包 71
3.1　多线程的团队协作：同步控制 71
3.1.1　关键字synchronized的功能扩展：重入锁 72
3.1.2　重入锁的好搭档：Condition 81
3.1.3　允许多个线程同时访问：信号量（Semaphore） 85
3.1.4　ReadWriteLock读写锁 86
3.1.5　倒计数器：CountDownLatch 89
3.1.6　循环栅栏：CyclicBarrier 91
3.1.7　线程阻塞工具类：LockSupport 94
3.1.8 Guava和RateLimiter限流 98
3.2　线程复用：线程池 101
3.2.1　什么是线程池 102
3.2.2　不要重复发明轮子：JDK对线程池的支持 102
3.2.3　刨根究底：核心线程池的内部实现 108
3.2.4　超负载了怎么办：拒绝策略 112
3.2.5　自定义线程创建：ThreadFactory 115
3.2.6　我的应用我做主：扩展线程池 116
3.2.7　合理的选择：优化线程池线程数量 119
3.2.8　堆栈去哪里了：在线程池中寻找堆栈 120
3.2.9　分而治之：Fork/Join框架 124
3.2.10　Guava中对线程池的扩展 128
3.3　不要重复发明轮子：JDK的并发容器 130
3.3.1　超好用的工具类：并发集合简介 130
3.3.2　线程安全的HashMap 131
3.3.3　有关List的线程安全 132
3.3.4　高效读写的队列：深度剖析ConcurrentLinkedQueue类 132
3.3.5　高效读取：不变模式下的CopyOnWriteArrayList类 138
3.3.6　数据共享通道：BlockingQueue 139
3.3.7　随机数据结构：跳表（SkipList） 144
3.4　使用JMH进行性能测试 146
3.4.1　什么是JMH 147
3.4.2　Hello JMH 147
3.4.3　JMH的基本概念和配置 150
3.4.4　理解JMH中的Mode 151
3.4.5　理解JMH中的State 153
3.4.6　有关性能的一些思考 154
3.4.7　CopyOnWriteArrayList类与ConcurrentLinkedQueue类 157
第4章　锁的优化及注意事项 161
4.1　有助于提高锁性能的几点建议 162
4.1.1　减少锁持有时间 162
4.1.2　减小锁粒度 163
4.1.3　用读写分离锁来替换独占锁 165
4.1.4　锁分离 165
4.1.5　锁粗化 168
4.2　Java虚拟机对锁优化所做的努力 169
4.2.1　锁偏向 169
4.2.2　轻量级锁 169
4.2.3　自旋锁 170
4.2.4　锁消除 170
4.3　人手一支笔：ThreadLocal 171
4.3.1　ThreadLocal的简单使用 171
4.3.2　ThreadLocal的实现原理 173
4.3.3　对性能有何帮助 179
4.4　无锁 182
4.4.1　与众不同的并发策略：比较交换 182
4.4.2　无锁的线程安全整数：AtomicInteger 183
4.4.3　Java中的指针：Unsafe类 185
4.4.4　无锁的对象引用：AtomicReference 187
4.4.5　带有时间戳的对象引用：AtomicStampedReference 190
4.4.6　数组也能无锁：AtomicIntegerArray 193
4.4.7　让普通变量也享受原子操作：AtomicIntegerFieldUpdater 194
4.4.8　挑战无锁算法：无锁的Vector实现 196
4.4.9　让线程之间互相帮助：细看SynchronousQueue的实现 201
4.5　有关死锁的问题 205
第5章　并行模式与算法 209
5.1　探讨单例模式 209
5.2　不变模式 213
5.3　生产者-消费者模式 215
5.4　高性能的生产者-消费者模式：无锁的实现 220
5.4.1　无锁的缓存框架：Disruptor 221
5.4.2　用Disruptor框架实现生产者-消费者模式的案例 222
5.4.3　提高消费者的响应时间：选择合适的策略 225
5.4.4　CPU Cache的优化：解决伪共享问题 226
5.5　Future模式 230
5.5.1　Future模式的主要角色 232
5.5.2　Future模式的简单实现 233
5.5.3　JDK中的Future模式 236
5.5.4　Guava对Future模式的支持 238
5.6　并行流水线 240
5.7　并行搜索 244
5.8　并行排序 246
5.8.1　分离数据相关性：奇偶交换排序 246
5.8.2　改进的插入排序：希尔排序 250
5.9　并行算法：矩阵乘法 254
5.10　准备好了再通知我：网络NIO 258
5.10.1　基于Socket的服务端多线程模式 259
5.10.2　使用NIO进行网络编程 264
5.10.3　使用NIO来实现客户端 272
5.11　读完了再通知我：AIO 274
5.11.1　AIO EchoServer的实现 275
5.11.2　AIO Echo客户端的实现 277
第6章　Java 8/9/10与并发 281
6.1　Java 8的函数式编程简介 281
6.1.1　函数作为一等公民 282
6.1.2　无副作用 283
6.1.3　声明式的（Declarative） 283
6.1.4　不变的对象 284
6.1.5　易于并行 284
6.1.6　更少的代码 284
6.2　函数式编程基础 285
6.2.1　FunctionalInterface注释 285
6.2.2　接口默认方法 286
6.2.3　lambda表达式 290
6.2.4　方法引用 291
6.3　一步一步走入函数式编程 293
6.4　并行流与并行排序 298
6.4.1　使用并行流过滤数据 298
6.4.2　从集合得到并行流 299
6.4.3　并行排序 299
6.5　增强的Future：CompletableFuture 300
6.5.1　完成了就通知我 300
6.5.2　异步执行任务 301
6.5.3　流式调用 303
6.5.4　CompletableFuture中的异常处理 303
6.5.5　组合多个CompletableFuture 304
6.5.6　支持timeout的 CompletableFuture 306
6.6　读写锁的改进：StampedLock 306
6.6.1　StampedLock使用示例 307
6.6.2　StampedLock的小陷阱 308
6.6.3　有关StampedLock的实现思想 310
6.7　原子类的增强 313
6.7.1　更快的原子类：LongAdder 314
6.7.2　LongAdder功能的增强版：LongAccumulator 320
6.8　ConcurrentHashMap的增强 321
6.8.1　foreach操作 321
6.8.2　reduce操作 321
6.8.3　条件插入 322
6.8.4　search操作 323
6.8.5　其他新方法 324
6.9　发布和订阅模式 324
6.9.1 简单的发布订阅例子 326
6.9.2 数据处理链 328
第7章　使用Akka构建高并发程序 331
7.1　新并发模型：Actor 332
7.2　Akka之Hello World 332
7.3　有关消息投递的一些说明 336
7.4　Actor的生命周期 337
7.5　监督策略 341
7.6　选择Actor 346
7.7　消息收件箱（Inbox） 346
7.8　消息路由 348
7.9　Actor的内置状态转换 351
7.10　询问模式：Actor中的Future 354
7.11　多个Actor同时修改数据：Agent 356
7.12　像数据库一样操作内存数据：软件事务内存 359
7.13　一个有趣的例子：并发粒子群的实现 363
7.13.1　什么是粒子群算法 364
7.13.2　粒子群算法的计算过程 364
7.13.3　粒子群算法能做什么 366
7.13.4　使用Akka实现粒子群 367
第8章　并行程序调试 375
8.1　准备实验样本 375
8.2　正式起航 376
8.3　挂起整个虚拟机 379
8.4　调试进入ArrayList内部 380
第9章　多线程优化示例—Jetty核心代码分析 385
9.1　Jetty简介与架构 385
9.2　Jetty服务器初始化 387
9.2.1　初始化线程池 387
9.2.2　初始化ScheduledExecutorScheduler 389
9.2.3　初始化ByteBufferPool 390
9.2.4　维护ConnectionFactory 393
9.2.5　计算ServerConnector的线程数量 394
9.3　启动Jetty服务器 394
9.3.1　设置启动状态 394
9.3.2　注册ShutdownMonitor 395
9.3.3　计算系统的线程数量 395
9.3.4　启动QueuedThreadPool 396
9.3.5　启动Connector 396
9.4　处理HTTP请求 399
9.4.1　Accept成功 399
9.4.2　请求处理 401

关于Java与并行
由于单核CPU的主频逐步逼近极限，多核CPU架构成了一种必然的技术趋势，因此多线程并行程序便显得越来越重要。并行计算的一个重要应用场景就是服务端编程。目前服务端CPU的核心数已经轻松超越10个，而Java显然已经成为当下最流行的服务端编程语言，且已经更新到JDK 10，因此熟悉和了解基于Java的并行程序开发有着重要的实用价值。
本书的体系结构
本书立足于实际开发，又不缺乏理论介绍，力求通俗易懂、循序渐进。本书共分为9章。
第1章主要介绍了并行计算中相关的一些基本概念，树立读者对并行计算的基本认识，介绍了两个重要的并行性能评估定律，以及Java内存模型JMM。
第2章介绍了Java并行程序开发的基础，包括Java中Thread的基本使用方法等，也详细介绍了并行程序容易引发的一些错误，以及容易出现的误用。
第3章介绍了JDK内部对并行程序开发的支持，主要介绍juc（java.util.concurrent）中一些工具的使用方法、各自的特点及它们的内部实现原理。
第4章介绍了在开发过程中可以进行的对锁的优化，也进一步简要描述了Java虚拟机层面对并行程序的优化支持。此外，还花费一定的篇幅介绍了无锁的计算。
第5章介绍了并行程序设计中常见的一些设计模式，以及一些典型的并行算法和使用方法，其中包括重要的Java NIO和AIO的介绍。
第6章介绍了Java 8/9/10为并行计算做的改进，包括并行流、CompletableFuture、StampedLock、LongAdder，以及发布和订阅模式等。
第7章主要介绍了高并发框架Akka的基本使用方法，并使用Akka框架实现了一个简单的粒子群算法，模拟超高并发的场景。
第8章介绍了使用Eclipse进行多线程调试的方法，并演示了通过Eclipse进行多线程调试重现ArrayList的线程不安全问题。
第9章介绍了Jetty，并分析了Jetty的一些关键代码，主要展示它在高并发优化中所做的一些努力，也为读者学会并深入理解高并发带来一些提示和思考。
本书特色
本书的主要特色如下。
1.    结构清晰。本书一共9章，总体上循序渐进，逐步提升。每一章都有鲜明的侧重点，有利于读者快速抓住重点。
2.    理论结合实战。本书注重实战，书中重要的知识点都安排了代码实例，帮助读者理解。同时也不忘对系统的内部实现原理进行深度剖析。
3.    通俗易懂。本书尽量避免采用过于理论化的描述方式，简单的白话文风格贯穿全书，配图基本上为手工绘制，降低了理解难度，并尽量做到读者在阅读过程中少盲点、无盲点。
适合阅读人群
虽然本书力求通俗，但是要通读本书并取得良好的学习效果，要求读者具备基本的Java知识或者一定的编程经验。因此，本书适合以下读者。
     拥有一定开发经验的Java平台开发人员（Java、Scala、JRuby等）。
     软件设计师、架构师。
     系统调优人员。
     有一定的Java编程基础并希望进一步加深对并行程序的理解的研发人员。
本书的约定和更新
本书在叙述过程中，有如下约定。
     本书所述的JDK 1.5、JDK 1.6、JDK 1.7、JDK 1.8、JDK 1.9、JDK 1.10分别等同于JDK 5、JDK 6、JDK 7、JDK 8、JDK 9、JDK 10。
     如无特殊说明，本书的程序、示例均在JDK 1.8以上环境中运行。

相较前一版，本书的主要更新如下。
1. 第3章增加的内容如下。
     使用JMH进行性能测试。
     CopyOnWriteArrayList ConcurrentLinkedQueue性能测试。
     使用Guava的RateLimiter限流。
     Guava中对线程池的扩展。
     介绍JDK中ArrayBlockingQueue的算法。

2. 第5章增加的内容如下。
     Guava对Future模式的支持。

3. 第6章增加的内容如下。
     支持timeout的CompletableFuture。
     ConcurrentHashMap在新版本JDK中的增强。
     发布和订阅模式。

4. 增加第9章，主要介绍Jetty多线程优化。从细节入手分析Jetty在多线程并发方面做出的努力和优化，对实践应用具有极强的参考价值。
联系作者
本书的写作过程远比我想象得艰辛，为了让全书能够更清楚、更准确地表达和论述，我经历了很多个不眠之夜，即使现在回想起来，我也忍不住会打个寒战。由于写作水平的限制，书中难免会有不妥之处，望读者谅解。
为此，如果读者有任何疑问或者建议，非常欢迎大家加入QQ群254693571，一起探讨学习中的困难、分享学习经验，我期待与大家一起交流、共同进步。同时，大家也可以关注我的博客http://www.uucode.net/。欢迎大家去博文视点社区下载本书推荐的参考文献。
感谢
本书能够面世，是因为得到了众人的支持。首先，要感谢我的妻子，她始终不辞辛劳、毫无怨言地对我照顾有加，才让我得以腾出大量时间安心工作。其次，要感谢所有编辑为我一次又一次地审稿改错，批评指正，促进本书逐步完善。最后，感谢我的母亲三十年如一日对我的体贴和关心。
葛一鸣

毫无疑问，Java是目前服务端程序常用的编程语言之一。大量的服务端应用基于这个看似简单的开发语言，然而容易入门并不代表容易精通。其中高并发程序设计就是一个重点，也是一个难点。对于Java，如果你已入门并迫切希望自己可以更上一层楼，那么本书毫无疑问将成为你的良师益友！全书内容深入且通俗易懂，示例丰富且注重循序渐进，可以极大地帮助你快速扫清进阶路上的主要障碍，助你成为一个知其然并知其所以然的高级Java工程师。

——Dataguru创始人、首席科学家黄志洪

7.3　有关消息投递的一些说明

整个Akka应用是由消息驱动的，消息是除Actor之外最重要的核心组件。作为并发程序中的核心组件，在Actor之间传递的消息应该满足不可变性，也就是不变模式。因为可变的消息无法高效的在并发环境中使用。理论上Akka中的消息可以使用任何对象实例，但在实际使用中，强烈推荐使用不可变的对象。一个典型的不可变对象的实现如下：

01 public final class ImmutableMessage {

02     private final int sequenceNumber;

03

04     private final List values;

05

06     public ImmutableMessage(int sequenceNumber, List values) {

07         this.sequenceNumber = sequenceNumber;

08         this.values = Collections.unmodifiableList(new ArrayList(values));

09     }

10

11     public int getSequenceNumber() {

12         return sequenceNumber;

13     }

14

15     public List getValues() {

16         return values;

17     }

18 }

上述代码实现了一个不可变的消息。注意代码中对final的使用，它声明了当前消息中的几个字段都是常量，在消息构造完成后，就不能再改变了。更需要注意的是，对于values字段，final关键字只能保证values引用的不可变性，无法保证values对象的不可变性。为了实现彻底的不可变性，代码第8行构造了一个不可变的List对象。

对于消息投递，大家可能还有另外一个疑问，那就是消息投递究竟是以何种策略进行的呢？也就是发出的消息一定会被对方接收到吗？如果接收不到会重发吗？有没有可能重复接收消息呢？

实际上，对于消息投递，我们可以有三种不同的策略。

第一种，称为至多一次投递。在这种策略中，每一条消息最多会被投递一次。在这种情况下，可能偶尔会出现消息投递失败，而导致消息丢失。

第二种，称为至少一次投递。在这种策略中，每一条消息至少会被投递一次，直到成功为止。因此在一些偶然的场合，接受者可能会收到重复的消息，但不会发生消息丢失。

第三种，称为精确的消息投递。也就是所有的消息保证被精确地投递并成功接收一次。既不会有丢失，也不会有重复接收。

很明显，第一种策略是最高性能、最低成本的。因为系统只要负责把消息送出去就可以了，不需要关注是否成功。第二种策略则需要保存消息投递的状态并不断充实。第三种策略则是成本最高且最不容易实现的。

那我们是否真的需要保证消息投递的可靠性呢？

答案是否定的。实际上，我们没有必要在Akka层保证消息的可靠性。这样做成本太高了，也是没有必要的。消息的可靠性更应该从应用的业务层去维护，因为也许在有些时候，丢失一些消息完全是符合应用要求的。因此，在使用Akka时，需要在业务层对此进行保证。

此外，对于消息投递Akka可以在一定程度上保证顺序性。比如，Actor A1向Actor A2顺序发送了M1、M2和M3三条消息，Actor A3向Actor A2顺序发送了M4、M5和M6三条消息，那么系统可以保证：

（1）如果M1没有丢失，那它一定先于M2和M3被Actor A2收到。

（2）如果M2没有丢失，那它一定先于M3被Actor A2收到。

（3）如果M4没有丢失，那它一定先于M5和M6被Actor A2收到。

（4）如果M5没有丢失，那它一定先于M6被Actor A2收到。

（5）对Actor A2来说，来自Actor A1和Actor A3的消息可能交织在一起，没有顺序保证。

值得注意的一点是，这种消息投递规则不具备可传递性，比如：Actor A向Actor C发送了M1，接着，Actor A向Actor B发送了M2，Actor B将M2转发给Actor C，那么在这种情况下，Actor C收到M1和M2的先后顺序是没有保证的。

7.4　Actor的生命周期

Actor在系统中产生后，也存在着“生老病死”的活动周期。Akka框架提供了若干回调函数，让我们得以在Actor的活动周期内进行一些业务相关的行为。Actor的生命周期如图7.1所示。

图7.1　Actor的生命周期

一个Actor在actorOf()函数被调用后开始建立，Actor实例创建后会回调preStart()方法。在这个方法里，我们可以进行一些资源的初始化工作。在Actor的工作过程中，可能会出现一些异常，这种情况下Actor需要重启。当Actor被重启时，会回调preRestart()方法（在老的实例上），接着系统会创建一个新的Actor对象实例（虽然是新的实例，但它们都表示同一个Actor）。当新的Actor实例创建后，会回调postRestart()方法，表示启动完成，同时新的实例将会代替旧的实例。停止一个Actor也有很多方式，你可以调用stop()方法或者给Actor发送一个PosionPill（毒药丸）。当Actor停止时，postStop()方法会被调用，同时这个Actor的监视者会收到一个Terminated消息。

下面让我们建立一个带有生命周期回调函数的Actor：

public class MyWorker extends UntypedActor {

    private final LoggingAdapter log = Logging.getLogger(getContext().system(), this);

    public static enum Msg {

        WORKING, DONE,CLOSE;

    }

    @Override

    public void preStart(){

        System.out.println(“MyWorker is starting”);

    }

    @Override

    public void postStop(){

        System.out.println(“MyWorker is stopping”);

    }

    @Override

    public void onReceive(Object msg) {

        if (msg == Msg.WORKING) {

            System.out.println(“I am working”);

        }

        if (msg == Msg.DONE) {

            System.out.println(“Stop working”);

        }if (msg == Msg.CLOSE) {

            System.out.println(“I will shutdown”);

            getSender().tell(Msg.CLOSE, getSelf());

            getContext().stop(getSelf());

        } else

            unhandled(msg);

    }

}

上述代码定义了一个名为MyWorker的Actor。它重载了preStart()和postStop()两个方法。一般来说，我们可以使用preStart()方法来初始化一些资源，使用postStop()方法来进行资源的释放。这个Actor很简单，当它收到WORKING消息时，就打印“I am working”，收到DONE消息时，打印“Stop working”。

接着，我们为MyWorker指定一个监视者，监视者就如同一个劳动监工，一旦MyWorker因为意外停止工作，监视者就会收到一个通知。

01 public class WatchActor extends UntypedActor {

02     private final LoggingAdapter log = Logging.getLogger(getContext().system(), this);

03

04     public WatchActor(ActorRef ref) {

05         getContext().watch(ref);

06     }

07

08     @Override

09     public void onReceive(Object msg) {

10         if (msg instanceof Terminated) {

11             System.out.println(String.format(“%s has terminated, shutting down system”,

12                     ((Terminated) msg).getActor().path()));

13             getContext().system().shutdown();

14         } else {

15             unhandled(msg);

16         }

17     }

18 }

上述代码定义了一个监视者WatchActor，它本质上也是一个Actor，但不同的是，它会在它的上下文中watch一个Actor（第5行）。如果将来这个被监视的Actor的退出终止，WatchActor就能收到一条Terminated消息（代码第10行）。在这里，我们将简单地打印终止消息Terminated中的相关Actor路径，并且关闭整个ActorSystem（第13行）。

主函数如下：

01 public class DeadMain {

02     public static void main(String[] args) {

03         ActorSystem system = ActorSystem

04                 .create(“deadwatch”, ConfigFactory.load(“samplehello.conf”));

05         ActorRef worker = system.actorOf(Props.create(MyWorker.class), “worker”);

06         system.actorOf(Props.create(WatchActor.class, worker), “watcher”);

07         worker.tell(MyWorker.Msg.WORKING, ActorRef.noSender());

08         worker.tell(MyWorker.Msg.DONE, ActorRef.noSender());

09         worker.tell(PoisonPill.getInstance(), ActorRef.noSender());

10     }

11 }

上述代码首先创建ActorSystem全局实例（第3~4行），接着创建MyWorker Actor和WatchActor。注意第6行的Props.create()方法，它的第1个参数为要创建的Actor类型，第2个参数为这个Actor的构造函数的参数（在这里，就是要调用WatchActor的构造函数）。接着，向MyWorker先后发送WORKING和DONE两条消息。最后在第9行，发送一条特殊的消息PoisonPill。PoisonPill意为毒药丸，它会直接“毒死”接收方，让其终止。

执行上述代码，系统输出如下：

MyWorker is starting

I am working

Stop working

MyWorker is stopping

akka://deadwatch/user/worker has terminated, shutting down system

从这个输出中可以看到，MyWorker生命周期中的两个回调函数及消息处理函数都被正常调用。最后一行输出也显示WatchActor正常监视到MyWorker的终止。