9787000050115

9787111632900 9787121350030

定价：￥79.00

作者：尼恩

I S B N ：978-7-111-63290-0条码书号：9787111632900上架日期：2019/8/15出版日期：2019/8/1版       次：1-1出 版 社：机械工业出版社

本书从操作底层的IO原理入手，同时提供高性能开发的实战案例，是一本高并发Java编程应用基础图书。

本书共分为12章。第1~5章为高并发基础，浅显易懂地剖析高并发IO的底层原理，细致地讲解Reactor高性能模式，图文并茂地介绍Java异步回调模式。这些原理方面的基础知识非常重要，会为读者打下坚实的基础，也是日常开发Java后台应用时解决实际问题的金钥匙。第6~9章为Netty原理和实战，是本书的重中之重，主要介绍高性能通信框架Netty、Netty的重要组件、单体IM的实战设计和模块实现。第10~12章对ZooKeeper、Curator API、Redis、Jedis API的使用进行详尽的说明，以提升读者设计和开发高并发、可扩展的能力。

本书兼具基础知识和实战案例，既可作为对Java NIO、高性能IO、高并发编程感兴趣的大专院校学生和初、中级Java工程师的学习参考书，也可作为在生产项目中需要用到Netty、Redis、ZooKeeper三大框架的架构师或项目人员的使用参考书。

书海寻梦图书专营店

前言

第1章  高并发时代的技能1

1.1  Netty为何这么火1

1.1.1  Netty火热的程度1

1.1.2  Netty是面试的必杀器2

1.2  高并发利器Redis2

1.2.1  什么是Redis2

1.2.2  Redis成为缓存事实标准的原因3

1.3  分布式利器ZooKeeper3

1.3.1  什么是ZooKeeper3

1.3.2  ZooKeeper的优势4

1.4  高并发IM的综合实践4

1.4.1  高并发IM的学习价值4

1.4.2  庞大的应用场景5

1.5  Netty、Redis、ZooKeeper实践计划5

1.5.1  第1天：Java NIO实践5

1.5.2  第2天：Reactor反应器模式实践6

1.5.3  第3天：异步回调模式实践7

1.5.4  第4天：Netty基础实践8

1.5.5  第5天：（Decoder）与编码器（Encoder）实践9

1.5.6  第6天：JSON和ProtoBuf序列化实践11

1.5.7  第7~10天：基于Netty的单聊实战12

1.5.8  第11天：ZooKeeper实践计划14

1.5.9  第12天：Redis实践计划14

1.6  本章小结16

第2章  高并发IO的底层原理17

2.1  IO读写的基础原理17

2.1.1  内核缓冲区与进程缓冲区18

2.1.2  详解典型的调用流程18

2.2  四种主要的IO模型19

2.2.1  同步阻塞IO（Blocking IO）20

2.2.2  同步非阻塞NIO（None Blocking IO）21

2.2.3  IO多路复用模型（IO Multiplexing）22

2.2.4  异步IO模型（Asynchronous IO）23

2.3  通过合理配置来支持百万级并发连接24

2.4  本章小结26

第3章  Java NIO通信基础详解27

3.1  Java NIO简介27

3.1.1  NIO和OIO的对比28

3.1.2  通道（Channel）28

3.1.3  Selector 选择器28

3.1.4  缓冲区（Buffer）29

3.2  详解NIO Buffer类及其属性29

3.2.1  Buffer类29

3.2.2  Buffer类的重要属性29

3.2.3  4个属性的小结31

3.3  详解NIO Buffer类的重要方法31

3.3.1  allocate()创建缓冲区31

3.3.2  put()写入到缓冲区32

3.3.3  flip()翻转33

3.3.4  get()从缓冲区读取34

3.3.5  rewind()倒带35

3.3.6  mark( )和reset( )37

3.3.7  clear( )清空缓冲区38

3.3.8  使用Buffer类的基本步骤38

3.4  详解NIO Channel（通道）类38

3.4.1  Channel（通道）的主要类型39

3.4.2  FileChannel文件通道39

3.4.3  使用FileChannel完成文件复制的实践案例41

3.4.4  SocketChannel套接字通道42

3.4.5  使用SocketChannel发送文件的实践案例44

3.4.6  DatagramChannel数据报通道46

3.4.7  使用DatagramChannel数据包通道发送数据的实践案例47

3.5  详解NIO Selector选择器49

3.5.1  选择器以及注册49

3.5.2  SelectableChannel可选择通道50

3.5.3  SelectionKey选择键50

3.5.4  选择器使用流程50

3.5.5  使用NIO实现Discard服务器的实践案例52

3.5.6  使用SocketChannel在服务器端接收文件的实践案例54

3.6  本章小结57

第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实践案例65

4.2.4  单线程Reactor反应器模式的缺点67

4.3  多线程的Reactor反应器模式68

4.3.1  多线程池Reactor反应器演进68

4.3.2  多线程Reactor 反应器的实践案例68

4.3.3  多线程Handler处理器的实践案例70

4.4  Reactor反应器模式小结72

4.5  本章小结73

第5章  并发基础中的Future异步回调模式74

5.1  从泡茶的案例说起74

5.2  join异步阻塞75

5.2.1  线程的join合并流程75

5.2.2  使用join实现异步泡茶喝的实践案例75

5.2.3  详解join合并方法77

5.3  FutureTask异步回调之重武器77

5.3.1  Callable接口77

5.3.2  初探FutureTask类78

5.3.3  Future接口79

5.3.4  再探FutureTask类79

5.3.5  使用FutureTask类实现异步泡茶喝的实践案例80

5.4  Guava的异步回调82

5.4.1  详解FutureCallback82

5.4.2  详解ListenableFuture83

5.4.3  ListenableFuture异步任务84

5.4.4  使用Guava实现泡茶喝的实践案例84

5.5  Netty的异步回调模式87

5.5.1  详解GenericFutureListener接口87

5.5.2  详解Netty的Future接口88

5.5.3  ChannelFuture的使用88

5.5.4  Netty的出站和入站异步回调89

5.6  本章小结90

第6章  Netty原理与基础91

6.1  一个Netty的实践案例DiscardServer91

6.1.1  创建一个Netty项目91

6.1.2  一个Netty服务器端程序92

6.1.3  业务处理器NettyDiscardHandler93

6.1.4  运行NettyDiscardServer94

6.2  解密Netty中的Reactor反应器模式95

6.2.1  回顾Reactor反应器模式中IO事件的处理流程95

6.2.2  Netty中的Channel通道组件96

6.2.3  Netty中的Reactor 反应器96

6.2.4  Netty中的Handler处理器97

6.2.5  Netty的流水线（Pipeline）98

6.3  详解Bootstrap启动器类100

6.3.1  父子通道100

6.3.2  EventLoopGroup线程组101

6.3.3  Bootstrap的启动流程101

6.3.4  ChannelOption通道选项104

6.4  详解Channel通道105

6.4.1  Channel通道的主要成员和方法105

6.4.2  EmbeddedChannel嵌入式通道107

6.5  详解Handler业务处理器108

6.5.1  ChannelInboundHandler通道入站处理器109

6.5.2  ChannelOutboundHandler通道出站处理器110

6.5.3  ChannelInitializer通道初始化处理器111

6.5.4  ChannelInboundHandler的生命周期的实践案例112

6.6  详解Pipeline流水线115

6.6.1  Pipeline入站处理流程115

6.6.2  Pipeline出站处理流程116

6.6.3  ChannelHandlerContext上下文118

6.6.4  截断流水线的处理118

6.6.5  Handler业务处理器的热拔插120

6.7  详解ByteBuf缓冲区122

6.7.1  ByteBuf的优势122

6.7.2  ByteBuf的逻辑部分123

6.7.3  ByteBuf的重要属性123

6.7.4  ByteBuf的三组方法124

6.7.5  ByteBuf基本使用的实践案例125

6.7.6  ByteBuf的引用计数127

6.7.7  ByteBuf的Allocator分配器128

6.7.8  ByteBuf缓冲区的类型130

6.7.9  三类ByteBuf使用的实践案例131

6.7.10  ByteBuf的自动释放133

6.8  ByteBuf浅层复制的使用方式136

6.8.1  slice切片浅层复制136

6.8.2  duplicate整体浅层复制137

6.8.3  浅层复制的问题138

6.9  EchoServer回显服务器的实践案例138

6.9.1  NettyEchoServer回显服务器的服务器端138

6.9.2  共享NettyEchoServerHandler处理器139

6.9.3  NettyEchoClient客户端代码140

6.9.4  NettyEchoClientHandler处理器142

6.10  本章小结143

第7章  Decoder与Encoder重要组件144

7.1  Decoder原理与实践144

7.1.1  ByteToMessageDecoder145

7.1.2  自定义Byte2IntegerDecoder整数的实践案例146

7.1.3  ReplayingDecoder148

7.1.4  整数的分包的实践案例149

7.1.5  字符串的分包的实践案例152

7.1.6  MessageToMessageDecoder156

7.2  开箱即用的Netty内置Decoder157

7.2.1  LineBasedFrameDecoder157

7.2.2  DelimiterBasedFrameDecoder158

7.2.3  LengthFieldBasedFrameDecoder159

7.2.4  多字段Head-Content协议数据帧解析的实践案例162

7.3  Encoder原理与实践164

7.3.1  MessageToByteEncoder编码器165

7.3.2  MessageToMessageEncoder编码器166

7.4 和编码器的结合167

7.4.1  ByteToMessageCodec编168

7.4.2  CombinedChannelDuplexHandler组合器169

7.5  本章小结169

第8章  JSON和ProtoBuf序列化171

8.1  详解粘包和拆包172

8.1.1  半包问题的实践案例172

8.1.2  什么是半包问题174

8.1.3  半包现象的原理174

8.2  JSON协议通信175

8.2.1  JSON序列化的通用类175

8.2.2  JSON序列化与反序列化的实践案例176

8.2.3  JSON传输的编码器和之原理178

8.2.4  JSON传输之服务器端的实践案例179

8.2.5  JSON传输之客户端的实践案例180

8.3  Protobuf协议通信182

8.3.1  一个简单的proto文件的实践案例182

8.3.2  控制台命令生成POJO和Builder183

8.3.3  Maven插件生成POJO和Builder183

8.3.4  消息POJO和Builder的使用之实践案例184

8.4  Protobuf编解码的实践案例187

8.4.1  Protobuf编码器和的原理187

8.4.2  Protobuf传输之服务器端的实践案例188

8.4.3  Protobuf传输之客户端的实践案例189

8.5  详解Protobuf协议语法191

8.5.1  proto的头部声明191

8.5.2  消息结构体与消息字段192

8.5.3  字段的数据类型193

8.5.4  其他的语法规范194

8.6  本章小结195

第9章  基于Netty的单体IM的开发实践196

9.1  自定义ProtoBuf编196

9.1.1  自定义Protobuf编码器197

9.1.2  自定义Protobuf198

9.1.3  IM中Protobuf消息格式的设计199

9.2  概述IM的登录流程202

9.2.1  图解登录/响应流程的9个环节203

9.2.2  客户端涉及的主要模块203

9.2.3  服务器端涉及的主要模块204

9.3  客户端的登录处理的实践案例204

9.3.1  LoginConsoleCommand和User POJO205

9.3.2  LoginSender发送器207

9.3.3  ClientSession客户端会话209

9.3.4  LoginResponceHandler登录响应处理器211

9.3.5  客户端流水线的装配212

9.4  服务器端的登录响应的实践案例213

9.4.1  服务器流水线的装配214

9.4.2  LoginRequestHandler登录请求处理器215

9.4.3  LoginProcesser用户验证逻辑216

9.4.4  EventLoop线程和业务线程相互隔离217

9.5  详解ServerSession服务器会话218

9.5.1  通道的容器属性219

9.5.2  ServerSession服务器端会话类220

9.5.3  SessionMap会话管理器222

9.6  点对点单聊的实践案例223

9.6.1  简述单聊的端到端流程223

9.6.2  客户端的ChatConsoleCommand收集聊天内容224

9.6.3  客户端的CommandController发送POJO224

9.6.4  服务器端的ChatRedirectHandler消息转发225

9.6.5  服务器端的ChatRedirectProcesser异步处理226

9.6.6  客户端的ChatMsgHandler接收POJO227

9.7  详解心跳检测228

9.7.1  网络连接的假死现象228

9.7.2  服务器端的空闲检测229

9.7.3  客户端的心跳报文230

9.8  本章小结232

第10章  ZooKeeper分布式协调233

10.1  ZooKeeper伪集群安装和配置233

10.1.1  创建数据目录和日志目录：234

10.1.2  创建myid文件234

10.1.3  创建和修改配置文件235

10.1.4  配置文件示例237

10.1.5  启动ZooKeeper伪集群238

10.2  使用ZooKeeper进行分布式存储239

10.2.1  详解ZooKeeper存储模型239

10.2.2  zkCli客户端命令清单240

10.3  ZooKeeper应用开发的实践241

10.3.1  ZkClient开源客户端介绍242

10.3.2  Curator开源客户端介绍242

10.3.3  Curator开发的环境准备243

10.3.4  Curator客户端实例的创建244

10.3.5  通过Curator创建ZNode节点245

10.3.6  在Curator中读取节点247

10.3.7  在Curator中更新节点248

10.3.8  在Curator中删除节点249

10.4  分布式命名服务的实践251

10.4.1  ID生成器252

10.4.2  ZooKeeper分布式ID生成器的实践案例253

10.4.3  集群节点的命名服务之实践案例254

10.4.4  使用ZK实现SnowFlakeID算法的实践案例256

10.5  分布式事件的重点261

10.5.1  Watcher标准的事件处理器261

10.5.2  NodeCache节点缓存的265

10.5.3  PathChildrenCache子节点267

10.5.4  Tree Cache节点树缓存272

10.6  分布式锁的原理与实践276

10.6.1  公平锁和可重入锁的原理276

10.6.2  ZooKeeper分布式锁的原理277

10.6.3  分布式锁的基本流程279

10.6.4  加锁的实现280

10.6.5  释放锁的实现285

10.6.6  分布式锁的使用287

10.6.7  Curator的InterProcessMutex可重入锁288

10.7  本章小结289

第11章  分布式缓存Redis290

11.1  Redis入门290

11.1.1  Redis安装和配置290

11.1.2  Redis客户端命令292

11.1.3  Redis Key的命名规范294

11.2  Redis数据类型295

11.2.1  String字符串295

11.2.2  List列表296

11.2.3  Hash哈希表297

11.2.4  Set集合298

11.2.5  Zset有序集合299

11.3  Jedis基础编程的实践案例300

11.3.1  Jedis操作String字符串301

11.3.2  Jedis操作List列表303

11.3.3  Jedis操作Hash哈希表304

11.3.4  Jedis操作Set集合305

11.3.5  Jedis操作Zset有序集合306

11.4  JedisPool连接池的实践案例308

11.4.1  JedisPool的配置308

11.4.2  JedisPool创建和预热310

11.4.3  JedisPool的使用312

11.5  使用spring-data-redis完成 CRUD的实践案例313

11.5.1  CRUD中应用缓存的场景313

11.5.2  配置spring-redis.xml315

11.5.3  使用RedisTemplate模板API316

11.5.4  使用RedisTemplate模板API完成CRUD的实践案例321

11.5.5  使用RedisCallback回调完成CRUD的实践案例323

11.6  Spring的Redis缓存注解325

11.6.1  使用Spring缓存注解完成CRUD的实践案例325

11.6.2  spring-redis.xml中配置的调整327

11.6.3  详解@CachePut和 @Cacheable注解328

11.6.4  详解@CacheEvict注解329

11.6.5  详解@Caching组合注解330

11.7  详解SpringEL（SpEL）331

11.7.1  SpEL运算符332

11.7.2  缓存注解中的SpringEL表达式334

11.8  本章小结336

第12章  亿级高并发IM架构的开发实践337

12.1  如何支撑亿级流量的高并发IM架构的理论基础337

12.1.1  亿级流量的架构的开发实践338

12.1.2  高并发架构的技术选型338

12.1.3  详解IM消息的序列化协议选型339

12.1.4  详解长连接和短连接339

12.2  分布式IM的命名服务的实践案例340

12.2.1  IM节点的POJO类341

12.2.2  IM节点的ImWorker类342

12.3  Worker集群的负载均衡之实践案例345

12.3.1  ImLoadBalance负载均衡器346

12.3.2  与WebGate的整合348

12.4  即时通信消息的路由和转发的实践案例349

12.4.1  IM路由器WorkerRouter349

12.4.2  IM转发器WorkerReSender352

12.5  Feign短连接RESTful调用354

12.5.1  短连接API的接口准备355

12.5.2  声明远程接口的本地代理355

12.5.3  远程API的本地调用356

12.6  分布式的在线用户统计的实践案例358

12.6.1  Curator的分布式计数器358

12.6.2  用户上线和下线的统计360

12.7  本章小结361

 商品基本信息,请以下列介绍为准

商品名称：

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

作者：

  葛一鸣

市场价：

  89元

ISBN号：

  9787121350030

出版社：

  电子工业出版社

商品类型：

  图书

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

在单核CPU时代，单任务在一个时间点只能执行单一程序，随着多核CPU的发展，并行程序开发变得尤为重要。本书主要介绍基于Java的并行程序设计基础、思路、方法和实战。一，立足于并发程序基础，详细介绍Java进行并行程序设计的基本方法。第二，进一步详细介绍了JDK对并行程序的强大支持，帮助读者快速、稳健地进行并行程序开发。第三，详细讨论了“锁”的优化和提高并行程序性能级别的方法和思路。第四，介绍了并行的基本设计模式，以及Java 8/9/10对并行程序的支持和改进。第五，介绍了高并发框架Akka的使用方法。第六，详细介绍了并行程序的调试方法。第七，分析Jetty代码并给出一些其在高并发优化方面的例子。本书内容丰富，实例典型，实用性强，适合有一定Java基础的技术开发人员阅读。

第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

.....

^_^:3ea0210563ec9249b8af907169efc097