4.8
用户推荐指数
计算机 类型
可以朗读 语音朗读
959千字 字数
2016-01-01 发行日期
展开全部

主编推荐语

入大厂、做架构的坚实基础。

内容简介

本套书包括《Java高并发核心编程·卷1，NIO、Netty、Redis、ZooKeeper》《Java高并发核心编程·卷2，多线程、锁、JMM、JUC、高并发设计模式》共两册。

《Java高并发核心编程·卷1，NIO、Netty、Redis、ZooKeeper》：本书从操作系统底层的IO原理入手讲解Java高并发核心编程知识，同时提供高性能开发的实战案例，是一本Java高并发编程的基础原理和实战图书。本书兼具基础知识和实战案例，既可作为对Java NIO、高性能IO、高并发编程感兴趣的大专院校学生以及初/中级Java工程师的自学图书，也可作为在生产项目中需要用到Netty、Redis、ZooKeeper三大框架的架构师或项目人员的参考书。

《Java高并发核心编程·卷2，多线程、锁、JMM、JUC、高并发设计模式》：本书聚焦Java高并发编程基础知识，介-绍Java多线程、线程池、内置锁、JMM、CAS、JUC、高并发设计模式等并发编程方面的核心原理和实战知识。本书共10章，既可以作为Java工程师、架构师的编程参考书，又可以作为参加互联网大厂面试、笔试的人员的学习参考书。

目录

  • Java高并发核心编程 卷1：NIO、Netty、Redis、ZooKeeper
  • 版权信息
  • 作者简介
  • 前言
  • 本书内容
  • 读者对象
  • 本书源代码下载
  • 勘误和支持
  • 致谢
  • 自序
  • 第1章 高并发时代的必备技能
  • 1.1 Netty为何这么火
  • 1.1.1 Netty火热的程度
  • 1.1.2 Netty是面试的必杀器
  • 1.2 高并发利器Redis
  • 1.2.1 什么是Redis
  • 1.2.2 Redis成为缓存事实标准的原因
  • 1.3 分布式利器ZooKeeper
  • 1.3.1 什么是ZooKeeper
  • 1.3.2 ZooKeeper的优势
  • 1.4 高性能HTTP通信技术
  • 1.4.1 十万级以上高并发场景中的高并发HTTP通信技术
  • 1.4.2 微服务之间的高并发RPC技术
  • 1.5 高并发IM的综合实战
  • 1.5.1 高并发IM的学习价值
  • 1.5.2 庞大的应用场景
  • 第2章 高并发IO的底层原理
  • 2.1 IO读写的基本原理
  • 2.1.1 内核缓冲区与进程缓冲区
  • 2.1.2 典型的系统调用流程
  • 2.2 四种主要的IO模型
  • 2.2.1 同步阻塞IO
  • 2.2.2 同步非阻塞IO
  • 2.2.3 IO多路复用
  • 2.2.4 异步IO
  • 2.3 通过合理配置来支持百万级并发连接
  • 第3章 Java NIO核心详解
  • 3.1 Java NIO简介
  • 3.1.1 NIO和OIO的对比
  • 3.1.2 通道
  • 3.1.3 选择器
  • 3.1.4 缓冲区
  • 3.2 详解NIO Buffer类及其属性
  • 3.2.1 Buffer类
  • 3.2.2 Buffer类的重要属性
  • 3.3 详解NIO Buffer类的重要方法
  • 3.3.1 allocate()
  • 3.3.2 put()
  • 3.3.3 flip()
  • 3.3.4 get()
  • 3.3.5 rewind()
  • 3.3.6 mark()和reset()
  • 3.3.7 clear()
  • 3.3.8 使用Buffer类的基本步骤
  • 3.4 详解NIO Channel类
  • 3.4.1 FileChannel
  • 3.4.2 使用FileChannel完成文件复制的实战案例
  • 3.4.3 SocketChannel
  • 3.4.4 使用SocketChannel发送文件的实战案例
  • 3.4.5 DatagramChannel
  • 3.4.6 使用DatagramChannel发送数据的实战案例
  • 3.5 详解NIO Selector
  • 3.5.1 选择器与注册
  • 3.5.2 SelectableChannel
  • 3.5.3 SelectionKey
  • 3.5.4 选择器使用流程
  • 3.5.5 使用NIO实现Discard服务器的实战案例
  • 3.5.6 使用SocketChannel在服务端接收文件的实战案例
  • 第4章 鼎鼎大名的Reactor模式
  • 4.1 Reactor模式的重要性
  • 4.1.1 为什么首先学习Reactor模式
  • 4.1.2 Reactor模式简介
  • 4.1.3 多线程OIO的致命缺陷
  • 4.2 单线程Reactor模式
  • 4.2.1 什么是单线程Reactor
  • 4.2.2 单线程Reactor的参考代码
  • 4.2.3 单线程Reactor模式的EchoServer的实战案例
  • 4.2.4 单线程Reactor模式的缺点
  • 4.3 多线程Reactor模式
  • 4.3.1 多线程版本的Reactor模式演进
  • 4.3.2 多线程版本Reactor的实战案例
  • 4.3.3 多线程版本Handler的实战案例
  • 4.4 Reactor模式的优缺点
  • 第5章 Netty核心原理与基础实战
  • 5.1 第一个Netty实战案例DiscardServer
  • 5.1.1 创建第一个Netty项目
  • 5.1.2 第一个Netty服务端程序
  • 5.1.3 业务处理器NettyDiscardHandler
  • 5.1.4 运行NettyDiscardServer
  • 5.2 解密Netty中的Reactor模式
  • 5.2.1 回顾Reactor模式中IO事件的处理流程
  • 5.2.2 Netty中的Channel
  • 5.2.3 Netty中的Reactor
  • 5.2.4 Netty中的Handler
  • 5.2.5 Netty中的Pipeline
  • 5.3 详解Bootstrap
  • 5.3.1 父子通道
  • 5.3.2 EventLoopGroup
  • 5.3.3 Bootstrap启动流程
  • 5.3.4 ChannelOption
  • 5.4 详解Channel
  • 5.4.1 Channel的主要成员和方法
  • 5.4.2 EmbeddedChannel
  • 5.5 详解Handler
  • 5.5.1 ChannelInboundHandler入站处理器
  • 5.5.2 ChannelOutboundHandler出站处理器
  • 5.5.3 ChannelInitializer通道初始化处理器
  • 5.5.4 ChannelInboundHandler的生命周期的实战案例
  • 5.6 详解Pipeline
  • 5.6.1 Pipeline入站处理流程
  • 5.6.2 Pipeline出站处理流程
  • 5.6.3 ChannelHandlerContext
  • 5.6.4 HeadContext与TailContext
  • 5.6.5 Pipeline入站和出站的双向链接操作
  • 5.6.6 截断流水线的入站处理传播过程
  • 5.6.7 在流水线上热插拔Handler
  • 5.7 详解ByteBuf
  • 5.7.1 ByteBuf的优势
  • 5.7.2 ByteBuf的组成部分
  • 5.7.3 ByteBuf的重要属性
  • 5.7.4 ByteBuf的方法
  • 5.7.5 ByteBuf基本使用的实战案例
  • 5.7.6 ByteBuf的引用计数
  • 5.7.7 ByteBuf的分配器
  • 5.7.8 ByteBuf缓冲区的类型
  • 5.7.9 两类ByteBuf使用的实战案例
  • 5.7.10 ByteBuf的自动创建与自动释放
  • 5.7.11 ByteBuf浅层复制的高级使用方式
  • 5.8 Netty的零拷贝
  • 5.8.1 通过CompositeByteBuf实现零拷贝
  • 5.8.2 通过wrap操作实现零拷贝
  • 5.9 EchoServer的实战案例
  • 5.9.1 NettyEchoServer
  • 5.9.2 NettyEchoServerHandler
  • 5.9.3 NettyEchoClient
  • 5.9.4 NettyEchoClientHandler
  • 第6章 Decoder与Encoder核心组件
  • 6.1 Decoder原理与实战
  • 6.1.1 ByteToMessageDecoder解码器处理流程
  • 6.1.2 自定义Byte2IntegerDecoder整数解码器
  • 6.1.3 ReplayingDecoder解码器
  • 6.1.4 整数的分包解码器的实战案例
  • 6.1.5 字符串的分包解码器的实战案例
  • 6.1.6 MessageToMessageDecoder解码器
  • 6.2 常用的内置Decoder
  • 6.2.1 LineBasedFrameDecoder解码器
  • 6.2.2 DelimiterBasedFrameDecoder解码器
  • 6.2.3 LengthFieldBasedFrameDecoder解码器
  • 6.2.4 多字段Head-Content协议数据包解析的实战案例
  • 6.3 Encoder原理与实战
  • 6.3.1 MessageToByteEncoder编码器
  • 6.3.2 MessageToMessageEncoder编码器
  • 6.4 解码器和编码器的结合
  • 6.4.1 ByteToMessageCodec编解码器
  • 6.4.2 CombinedChannelDuplexHandler组合器
  • 第7章 序列化与反序列化：JSON和Protobuf
  • 7.1 详解粘包和拆包
  • 7.1.1 半包问题的实战案例
  • 7.1.2 什么是半包问题
  • 7.1.3 半包问题的根因分析
  • 7.2 使用JSON协议通信
  • 7.2.1 JSON的核心优势
  • 7.2.2 JSON序列化与反序列化开源库
  • 7.2.3 JSON序列化与反序列化的实战案例
  • 7.2.4 JSON传输的编码器和解码器
  • 7.2.5 JSON传输的服务端的实战案例
  • 7.2.6 JSON传输的客户端的实战案例
  • 7.3 使用Protobuf协议通信
  • 7.3.1 一个简单的proto文件的实战案例
  • 7.3.2 通过控制台命令生成POJO和Builder
  • 7.3.3 通过Maven插件生成POJO和Builder
  • 7.3.4 Protobuf序列化与反序列化的实战案例
  • 7.4 Protobuf编解码的实战案例
  • 7.4.1 Netty内置的Protobuf基础编码器/解码器
  • 7.4.2 Protobuf传输的服务端的实战案例
  • 7.4.3 Protobuf传输的客户端的实战案例
  • 7.5 详解Protobuf协议语法
  • 7.5.1 proto文件的头部声明
  • 7.5.2 Protobuf的消息结构体与消息字段
  • 7.5.3 Protobuf字段的数据类型
  • 7.5.4 proto文件的其他语法规范
  • 第8章 基于Netty单体IM系统的开发实战
  • 8.1 自定义Protobuf编解码器
  • 8.1.1 自定义Protobuf编码器
  • 8.1.2 自定义Protobuf解码器
  • 8.1.3 IM系统中Protobuf消息格式的设计
  • 8.2 IM的登录流程
  • 8.2.1 图解登录/响应流程的环节
  • 8.2.2 客户端涉及的主要模块
  • 8.2.3 服务端涉及的主要模块
  • 8.3 客户端的登录处理的实战案例
  • 8.3.1 LoginConsoleCommand和User POJO
  • 8.3.2 LoginSender
  • 8.3.3 ClientSession
  • 8.3.4 LoginResponseHandler
  • 8.3.5 客户端流水线的装配
  • 8.4 服务端的登录响应的实战案例
  • 8.4.1 服务端流水线的装配
  • 8.4.2 LoginRequestHandler
  • 8.4.3 LoginProcesser
  • 8.4.4 EventLoop线程和业务线程相互隔离
  • 8.5 详解Session服务器会话
  • 8.5.1 通道的容器属性
  • 8.5.2 ServerSession服务端会话类
  • 8.5.3 SessionMap会话管理器
  • 8.6 点对点单聊的实战案例
  • 8.6.1 单聊的端到端流程
  • 8.6.2 客户端的ChatConsoleCommand收集聊天内容
  • 8.6.3 客户端的CommandController发送POJO
  • 8.6.4 服务端的ChatRedirectHandler进行消息转发
  • 8.6.5 服务端的ChatRedirectProcesser进行异步消息转发
  • 8.6.6 客户端的ChatMsgHandler聊天消息处理器
  • 8.7 详解心跳检测
  • 8.7.1 网络连接的假死现象
  • 8.7.2 服务端的空闲检测
  • 8.7.3 客户端的心跳发送
  • 第9章 HTTP原理与Web服务器实战
  • 9.1 高性能Web应用架构
  • 9.1.1 十万级并发的Web应用架构
  • 9.1.2 千万级高并发的Web应用架构
  • 9.2 详解HTTP应用层协议
  • 9.2.1 HTTP简介
  • 9.2.2 HTTP的请求URL
  • 9.2.3 HTTP的请求报文
  • 9.2.4 HTTP的响应报文
  • 9.2.5 HTTP中GET和POST的区别
  • 9.3 HTTP的演进
  • 9.3.1 HTTP的1.0版本
  • 9.3.2 HTTP的1.1版本
  • 9.3.3 HTTP的2.0版本
  • 9.4 基于Netty实现简单的Web服务器
  • 9.4.1 基于Netty的HTTP服务器演示实例
  • 9.4.2 基于Netty的HTTP请求的处理流程
  • 9.4.3 Netty内置的HTTP报文解码流程
  • 9.4.4 基于Netty的HTTP响应编码流程
  • 9.4.5 HttpEchoHandler回显业务处理器的实战案例
  • 9.4.6 使用Postman发送多种类型的请求体
  • 第10章 高并发HTTP通信的核心原理
  • 10.1 需要进行HTTP连接复用的高并发场景
  • 10.1.1 反向代理Nginx与Java Web应用服务之间的HTTP高并发通信
  • 10.1.2 微服务网关与微服务Provider实例之间的HTTP高并发通信
  • 10.1.3 分布式微服务Provider实例之间的RPC的HTTP高并发通信
  • 10.1.4 Java通过HTTP客户端访问REST接口服务的HTTP高并发通信
  • 10.2 详解传输层TCP
  • 10.2.1 TCP/IP的分层模型
  • 10.2.2 HTTP报文传输原理
  • 10.2.3 TCP的报文格式
  • 10.2.4 TCP的三次握手
  • 10.2.5 TCP的四次挥手
  • 10.2.6 三次握手、四次挥手的常见面试题
  • 10.3 TCP连接状态的原理与实验
  • 10.3.1 TCP/IP连接的11种状态
  • 10.3.2 通过netstat指令查看连接状态
  • 10.4 HTTP长连接原理
  • 10.4.1 HTTP长连接和短连接
  • 10.4.2 不同HTTP版本中的长连接选项
  • 10.5 服务端HTTP长连接技术
  • 10.5.1 应用服务器Tomcat的长连接配置
  • 10.5.2 Nginx承担服务端角色时的长连接配置
  • 10.5.3 服务端长连接设置的注意事项
  • 10.6 客户端HTTP长连接技术原理与实验
  • 10.6.1 HttpURLConnection短连接技术
  • 10.6.2 HTTP短连接的通信实验
  • 10.6.3 Apache HttpClient客户端的HTTP长连接技术
  • 10.6.4 Apache HttpClient客户端长连接实验
  • 10.6.5 Nginx承担客户端角色时的长连接技术
  • 第11章 WebSocket原理与实战
  • 11.1 WebSocket协议简介
  • 11.1.1 Ajax短轮询和Long Poll长轮询的原理
  • 11.1.2 WebSocket与HTTP之间的关系
  • 11.2 WebSocket回显演示程序开发
  • 11.2.1 WebSocket回显程序的客户端代码
  • 11.2.2 WebSocket相关的Netty内置处理类
  • 11.2.3 WebSocket的回显服务器
  • 11.2.4 WebSocket的业务处理器
  • 11.3 WebSocket协议通信的原理
  • 11.3.1 抓取WebSocket协议的本机数据包
  • 11.3.2 WebSocket握手过程
  • 11.3.3 WebSocket通信报文格式
  • 第12章 SSL/TLS核心原理与实战
  • 12.1 什么是SSL/TLS
  • 12.1.1 SSL/TLS协议的版本演进
  • 12.1.2 SSL/TLS协议的分层结构
  • 12.2 加密算法原理与实战
  • 12.2.1 哈希单向加密算法原理与实战
  • 12.2.2 对称加密算法原理与实战
  • 12.2.3 非对称加密算法原理与实战
  • 12.2.4 数字签名原理与实战
  • 12.3 SSL/TLS运行过程
  • 12.3.1 SSL/TLS第一阶段握手
  • 12.3.2 SSL/TLS第二阶段握手
  • 12.3.3 SSL/TLS第三阶段握手
  • 12.3.4 SSL/TLS第四阶段握手
  • 12.4 详解Keytool工具
  • 12.4.1 数字证书与身份识别
  • 12.4.2 存储密钥与证书文件格式
  • 12.4.3 使用Keytool工具管理密钥和证书
  • 12.5 使用Java程序管理密钥与证书
  • 12.5.1 使用Java操作数据证书所涉及的核心类
  • 12.5.2 使用Java程序创建密钥与仓库
  • 12.5.3 使用Java程序导出证书文件
  • 12.5.4 使用Java程序将数字证书导入信任仓库
  • 12.6 OIO通信中的SSL/TLS使用实战
  • 12.6.1 JSSE安全套接字扩展核心类
  • 12.6.2 JSSE安全套接字的创建过程
  • 12.6.3 OIO安全通信的Echo服务端实战
  • 12.6.4 OIO安全通信的Echo客户端实战
  • 12.7 单向认证与双向认证
  • 12.7.1 SSL/TLS单向认证
  • 12.7.2 使用证书信任管理器
  • 12.7.3 SSL/TLS双向认证
  • 12.8 Netty通信中的SSL/TLS使用实战
  • 12.8.1 Netty安全通信演示实例
  • 12.8.2 Netty内置SSLEngine处理器详解
  • 12.8.3 Netty的简单安全聊天器服务端程序
  • 12.9 HTTPS协议安全通信实战
  • 12.9.1 使用Netty实现HTTPS回显服务端程序
  • 12.9.2 通过HttpsURLConnection发送HTTPS请求
  • 12.9.3 HTTPS服务端与客户端的测试用例
  • 第13章 ZooKeeper分布式协调
  • 13.1 ZooKeeper伪集群安装和配置
  • 13.1.1 创建数据目录和日志目录
  • 13.1.2 创建myid文本文件
  • 13.1.3 创建和修改配置文件
  • 13.1.4 配置文件示例
  • 13.1.5 启动ZooKeeper伪集群
  • 13.2 使用ZooKeeper进行分布式存储
  • 13.2.1 详解ZooKeeper存储模型
  • 13.2.2 zkCli客户端指令清单
  • 13.3 ZooKeeper应用开发实战
  • 13.3.1 ZkClient开源客户端
  • 13.3.2 Curator开源客户端
  • 13.3.3 准备Curator开发环境
  • 13.3.4 创建Curator客户端实例
  • 13.3.5 通过Curator创建节点
  • 13.3.6 通过Curator读取节点
  • 13.3.7 通过Curator更新节点
  • 13.3.8 通过Curator删除节点
  • 13.4 分布式命名服务实战
  • 13.4.1 ID生成器
  • 13.4.2 ZooKeeper分布式ID生成器的实战案例
  • 13.4.3 集群节点的命名服务的实战案例
  • 13.4.4 结合ZooKeeper实现SnowFlake ID算法
  • 13.5 分布式事件监听的重点
  • 13.5.1 Watcher标准的事件处理器
  • 13.5.2 NodeCache节点缓存的监听
  • 13.5.3 PathCache子节点监听
  • 13.5.4 TreeCache节点树缓存
  • 13.6 分布式锁原理与实战
  • 13.6.1 公平锁和可重入锁的原理
  • 13.6.2 ZooKeeper分布式锁的原理
  • 13.6.3 分布式锁的基本流程
  • 13.6.4 加锁的实现
  • 13.6.5 释放锁的实现
  • 13.6.6 分布式锁的使用
  • 13.6.7 Curator的InterProcessMutex可重入锁
  • 13.6.8 ZooKeeper分布式锁的优缺点
  • 第14章 分布式缓存Redis实战
  • 14.1 Redis入门
  • 14.1.1 Redis的安装和配置
  • 14.1.2 Redis客户端命令
  • 14.1.3 Redis键的命名规范
  • 14.2 Redis数据类型
  • 14.2.1 String
  • 14.2.2 List
  • 14.2.3 Hash
  • 14.2.4 Set
  • 14.2.5 ZSet
  • 14.3 Jedis基础编程的实战案例
  • 14.3.1 Jedis操作String
  • 14.3.2 Jedis操作List
  • 14.3.3 Jedis操作Hash
  • 14.3.4 Jedis操作Set
  • 14.3.5 Jedis操作ZSet
  • 14.4 JedisPool连接池的实战案例
  • 14.4.1 JedisPool的配置
  • 14.4.2 JedisPool的创建和预热
  • 14.4.3 JedisPool的使用
  • 14.5 使用spring-data-redis完成CRUD的实战案例
  • 14.5.1 CRUD中应用缓存的场景
  • 14.5.2 配置spring-redis.xml
  • 14.5.3 RedisTemplate模板API
  • 14.5.4 使用RedisTemplate模板API完成CRUD的实战案例
  • 14.5.5 使用RedisCallback回调完成CRUD的实战案例
  • 14.6 Spring的Redis缓存注解
  • 14.6.1 使用Spring缓存注解完成CRUD的实战案例
  • 14.6.2 spring-redis.xml中配置的调整
  • 14.6.3 @CachePut和@Cacheable注解
  • 14.6.4 @CacheEvict注解
  • 14.6.5 @Caching组合注解
  • 14.7 详解SpEL
  • 14.7.1 SpEL运算符
  • 14.7.2 缓存注解中的SpEL表达式
  • 第15章 亿级高并发IM架构与实战
  • 15.1 支撑亿级流量的高并发IM架构的理论基础
  • 15.1.1 亿级流量的系统架构的开发实战
  • 15.1.2 高并发架构的技术选型
  • 15.1.3 详解IM消息的序列化协议选型
  • 15.1.4 详解长连接和短连接
  • 15.2 分布式IM的命名服务的实战案例
  • 15.2.1 IM节点的POJO类
  • 15.2.2 IM节点的ImWorker类
  • 15.3 Worker集群的负载均衡的实战案例
  • 15.3.1 ImLoadBalance负载均衡器
  • 15.3.2 与WebGate的整合
  • 15.4 即时通信消息的路由和转发的实战案例
  • 15.4.1 IM路由器WorkerRouter
  • 15.4.2 IM转发器PeerSender
  • 15.5 在线用户统计的实战案例
  • 15.5.1 Curator的分布式计数器
  • 15.5.2 用户上线和下线的统计
  • Java高并发核心编程 卷2：多线程、锁、JMM、JUC、高并发设计模式
  • 版权信息
  • 前言
  • 本书内容
  • 读者对象
  • 本书源代码下载
  • 勘误和支持
  • 致谢
  • 自序
  • 第1章 多线程原理与实战
  • 1.1 两个技术面试故事
  • 1.2 无处不在的进程和线程
  • 1.2.1 进程的基本原理
  • 1.2.2 线程的基本原理
  • 1.2.3 进程与线程的区别
  • 1.3 创建线程的4种方法
  • 1.3.1 Thread类详解
  • 1.3.2 创建一个空线程
  • 1.3.3 线程创建方法一：继承Thread类创建线程类
  • 1.3.4 线程创建方法二：实现Runnable接口创建线程目标类
  • 1.3.5 优雅创建Runnable线程目标类的两种方式
  • 1.3.6 通过实现Runnable接口的方式创建线程目标类的优缺点
  • 1.3.7 线程创建方法三：使用Callable和FutureTask创建线程
  • 1.3.8 线程创建方法四：通过线程池创建线程
  • 1.4 线程的核心原理
  • 1.4.1 线程的调度与时间片
  • 1.4.2 线程的优先级
  • 1.4.3 线程的生命周期
  • 1.4.4 一个线程状态的简单演示案例
  • 1.4.5 使用Jstack工具查看线程状态
  • 1.5 线程的基本操作
  • 1.5.1 线程名称的设置和获取
  • 1.5.2 线程的sleep操作
  • 1.5.3 线程的interrupt操作
  • 1.5.4 线程的join操作
  • 1.5.5 线程的yield操作
  • 1.5.6 线程的daemon操作
  • 1.5.7 线程状态总结
  • 1.6 线程池原理与实战
  • 1.6.1 JUC的线程池架构
  • 1.6.2 Executors的4种快捷创建线程池的方法
  • 1.6.3 线程池的标准创建方式
  • 1.6.4 向线程池提交任务的两种方式
  • 1.6.5 线程池的任务调度流程
  • 1.6.6 ThreadFactory（线程工厂）
  • 1.6.7 任务阻塞队列
  • 1.6.8 调度器的钩子方法
  • 1.6.9 线程池的拒绝策略
  • 1.6.10 线程池的优雅关闭
  • 1.6.11 Executors快捷创建线程池的潜在问题
  • 1.7 确定线程池的线程数
  • 1.7.1 按照任务类型对线程池进行分类
  • 1.7.2 为IO密集型任务确定线程数
  • 1.7.3 为CPU密集型任务确定线程数
  • 1.7.4 为混合型任务确定线程数
  • 1.8 ThreadLocal原理与实战
  • 1.8.1 ThreadLocal的基本使用
  • 1.8.2 ThreadLocal的使用场景
  • 1.8.3 使用ThreadLocal进行线程隔离
  • 1.8.4 使用ThreadLocal进行跨函数数据传递
  • 1.8.5 ThreadLocal内部结构演进
  • 1.8.6 ThreadLocal源码分析
  • 1.8.7 ThreadLocalMap源码分析
  • 1.8.8 ThreadLocal综合使用案例
  • 第2章 Java内置锁的核心原理
  • 2.1 线程安全问题
  • 2.1.1 自增运算不是线程安全的
  • 2.1.2 临界区资源与临界区代码段
  • 2.2 synchronized关键字
  • 2.2.1 synchronized同步方法
  • 2.2.2 synchronized同步块
  • 2.2.3 静态的同步方法
  • 2.3 生产者-消费者问题
  • 2.3.1 生产者-消费者模式
  • 2.3.2 一个线程不安全的实现版本
  • 2.3.3 一个线程安全的实现版本
  • 2.4 Java对象结构与内置锁
  • 2.4.1 Java对象结构
  • 2.4.2 Mark Word的结构信息
  • 2.4.3 使用JOL工具查看对象的布局
  • 2.4.4 大小端问题
  • 2.4.5 无锁、偏向锁、轻量级锁和重量级锁
  • 2.5 偏向锁的原理与实战
  • 2.5.1 偏向锁的核心原理
  • 2.5.2 偏向锁的演示案例
  • 2.5.3 偏向锁的膨胀和撤销
  • 2.6 轻量级锁的原理与实战
  • 2.6.1 轻量级锁的核心原理
  • 2.6.2 轻量级锁的演示案例
  • 2.6.3 轻量级锁的分类
  • 2.6.4 轻量级锁的膨胀
  • 2.7 重量级锁的原理与实战
  • 2.7.1 重量级锁的核心原理
  • 2.7.2 重量级锁的开销
  • 2.7.3 重量级锁的演示案例
  • 2.8 偏向锁、轻量级锁与重量级锁的对比
  • 2.9 线程间通信
  • 2.9.1 线程间通信的定义
  • 2.9.2 低效的线程轮询
  • 2.9.3 wait方法和notify方法的原理
  • 2.9.4 “等待-通知”通信模式演示案例
  • 2.9.5 生产者-消费者之间的线程间通信
  • 2.9.6 需要在synchronized同步块的内部使用wait和notify
  • 第3章 CAS原理与JUC原子类
  • 3.1 什么是CAS
  • 3.1.1 Unsafe类中的CAS方法
  • 3.1.2 使用CAS进行无锁编程
  • 3.1.3 使用无锁编程实现轻量级安全自增
  • 3.1.4 字段偏移量的计算
  • 3.2 JUC原子类
  • 3.2.1 JUC中的Atomic原子操作包
  • 3.2.2 基础原子类AtomicInteger
  • 3.2.3 数组原子类AtomicIntegerArray
  • 3.2.4 AtomicInteger线程安全原理
  • 3.3 对象操作的原子性
  • 3.3.1 引用类型原子类
  • 3.3.2 属性更新原子类
  • 3.4 ABA问题
  • 3.4.1 了解ABA问题
  • 3.4.2 ABA问题解决方案
  • 3.4.3 使用AtomicStampedReference解决ABA问题
  • 3.4.4 使用AtomicMarkableReference解决ABA问题
  • 3.5 提升高并发场景下CAS操作的性能
  • 3.5.1 以空间换时间：LongAdder
  • 3.5.2 LongAdder的原理
  • 3.6 CAS在JDK中的广泛应用
  • 3.6.1 CAS操作的弊端和规避措施
  • 3.6.2 CAS操作在JDK中的应用
  • 第4章 可见性与有序性的原理
  • 4.1 CPU物理缓存结构
  • 4.2 并发编程的三大问题
  • 4.2.1 原子性问题
  • 4.2.2 可见性问题
  • 4.2.3 有序性问题
  • 4.3 硬件层的MESI协议原理
  • 4.3.1 总线锁和缓存锁
  • 4.3.2 MSI协议
  • 4.3.3 MESI协议及RFO请求
  • 4.3.4 volatile的原理
  • 4.4 有序性与内存屏障
  • 4.4.1 重排序
  • 4.4.2 As-if-Serial规则
  • 4.4.3 硬件层面的内存屏障
  • 4.5 JMM详解
  • 4.5.1 什么是Java内存模型
  • 4.5.2 JMM与JVM物理内存的区别
  • 4.5.3 JMM的8个操作
  • 4.5.4 JMM如何解决有序性问题
  • 4.5.5 volatile语义中的内存屏障
  • 4.6 Happens-Before规则
  • 4.6.1 Happens-Before规则介绍
  • 4.6.2 规则1：顺序性规则
  • 4.6.3 规则2：volatile规则
  • 4.6.4 规则3：传递性规则
  • 4.6.5 规则4：监视锁规则
  • 4.6.6 规则5：start()规则
  • 4.6.7 规则6：join()规则
  • 4.7 volatile不具备原子性
  • 4.7.1 volatile变量的自增实例
  • 4.7.2 volatile变量的复合操作不具备原子性的原理
  • 第5章 JUC显式锁的原理与实战
  • 5.1 显式锁
  • 5.1.1 显式锁Lock接口
  • 5.1.2 可重入锁ReentrantLock
  • 5.1.3 使用显式锁的模板代码
  • 5.1.4 基于显式锁进行“等待-通知”方式的线程间通信
  • 5.1.5 LockSupport
  • 5.1.6 显式锁的分类
  • 5.2 悲观锁和乐观锁
  • 5.2.1 悲观锁存在的问题
  • 5.2.2 通过CAS实现乐观锁
  • 5.2.3 不可重入的自旋锁
  • 5.2.4 可重入的自旋锁
  • 5.2.5 CAS可能导致“总线风暴”
  • 5.2.6 CLH自旋锁
  • 5.3 公平锁与非公平锁
  • 5.3.1 非公平锁实战
  • 5.3.2 公平锁实战
  • 5.4 可中断锁与不可中断锁
  • 5.4.1 锁的可中断抢占
  • 5.4.2 死锁的监测与中断
  • 5.5 共享锁与独占锁
  • 5.5.1 独占锁
  • 5.5.2 共享锁Semaphore
  • 5.5.3 共享锁CountDownLatch
  • 5.6 读写锁
  • 5.6.1 读写锁ReentrantReadWriteLock
  • 5.6.2 锁的升级与降级
  • 5.6.3 StampedLock
  • 第6章 AQS抽象同步器的核心原理
  • 6.1 锁与队列的关系
  • 6.2 AQS的核心成员
  • 6.2.1 状态标志位
  • 6.2.2 队列节点类
  • 6.2.3 FIFO双向同步队列
  • 6.2.4 JUC显式锁与AQS的关系
  • 6.2.5 ReentrantLock与AQS的组合关系
  • 6.3 AQS中的模板模式
  • 6.3.1 模板模式
  • 6.3.2 一个模板模式的参考实现
  • 6.3.3 AQS的模板流程
  • 6.3.4 AQS中的钩子方法
  • 6.4 通过AQS实现一把简单的独占锁
  • 6.4.1 简单的独占锁的UML类图
  • 6.4.2 简单的独占锁的实现
  • 6.4.3 SimpleMockLock测试用例
  • 6.5 AQS锁抢占的原理
  • 6.5.1 显式锁抢占的总体流程
  • 6.5.2 AQS模板方法：acquire(arg)
  • 6.5.3 钩子实现：tryAcquire(arg)
  • 6.5.4 直接入队：addWaiter
  • 6.5.5 自旋入队：enq
  • 6.5.6 自旋抢占：acquireQueued()
  • 6.5.7 挂起预判：shouldParkAfterFailedAcquire()
  • 6.5.8 线程挂起：parkAndCheckInterrupt()
  • 6.6 AQS的两个关键点：节点的入队和出队
  • 6.6.1 节点的自旋入队
  • 6.6.2 节点的出队
  • 6.7 AQS锁释放的原理
  • 6.7.1 SimpleMockLock独占锁的释放流程
  • 6.7.2 AQS模板方法：release()
  • 6.7.3 钩子实现：tryRelease()
  • 6.7.4 唤醒后继：unparkSuccessor()
  • 6.8 ReentrantLock的抢锁流程
  • 6.8.1 ReentrantLock非公平锁的抢占流程
  • 6.8.2 非公平锁的同步器子类
  • 6.8.3 非公平抢占的钩子方法：tryAcquire(arg)
  • 6.8.4 ReentrantLock公平锁的抢占流程
  • 6.8.5 公平锁的同步器子类
  • 6.8.6 公平抢占的钩子方法：tryAcquire(arg)
  • 6.8.7 是否有后继节点的判断
  • 6.9 AQS条件队列
  • 6.9.1 Condition基本原理
  • 6.9.2 await()等待方法原理
  • 6.9.3 signal()唤醒方法原理
  • 6.10 AQS的实际应用
  • 第7章 JUC容器类
  • 7.1 线程安全的同步容器类
  • 7.2 JUC高并发容器
  • 7.3 CopyOnWriteArrayList
  • 7.3.1 CopyOnWriteArrayList的使用
  • 7.3.2 CopyOnWriteArrayList的原理
  • 7.3.3 CopyOnWriteArrayList读取操作
  • 7.3.4 CopyOnWriteArrayList写入操作
  • 7.3.5 CopyOnWriteArrayList的迭代器实现
  • 7.4 BlockingQueue
  • 7.4.1 BlockingQueue的特点
  • 7.4.2 阻塞队列的常用方法
  • 7.4.3 常见的BlockingQueue
  • 7.4.4 ArrayBlockingQueue的基本使用
  • 7.4.5 ArrayBlockingQueue构造器和成员
  • 7.4.6 非阻塞式添加元素：add()、offer()方法的原理
  • 7.4.7 阻塞式添加元素：put()方法的原理
  • 7.4.8 非阻塞式删除元素：poll()方法的原理
  • 7.4.9 阻塞式删除元素：take()方法的原理
  • 7.4.10 peek()直接返回当前队列的头元素
  • 7.5 ConcurrentHashMap
  • 7.5.1 HashMap和HashTable的问题
  • 7.5.2 JDK 1.7版本ConcurrentHashMap的结构
  • 7.5.3 JDK 1.7版本ConcurrentHashMap的核心原理
  • 7.5.4 JDK 1.8版本ConcurrentHashMap的结构
  • 7.5.5 JDK 1.8版本ConcurrentHashMap的核心原理
  • 7.5.6 JDK 1.8版本ConcurrentHashMap的核心源码
  • 第8章 高并发设计模式
  • 8.1 线程安全的单例模式
  • 8.1.1 从饿汉式单例到懒汉式单例
  • 8.1.2 使用内置锁保护懒汉式单例
  • 8.1.3 双重检查锁单例模式
  • 8.1.4 使用双重检查锁+volatile
  • 8.1.5 使用静态内部类实现懒汉式单例模式
  • 8.2 Master-Worker模式
  • 8.2.1 Master-Worker模式的参考实现
  • 8.2.2 Netty中Master-Worker模式的实现
  • 8.2.3 Nginx中Master-Worker模式的实现
  • 8.3 ForkJoin模式
  • 8.3.1 ForkJoin模式的原理
  • 8.3.2 ForkJoin框架
  • 8.3.3 ForkJoin框架使用实战
  • 8.3.4 ForkJoin框架的核心API
  • 8.3.5 工作窃取算法
  • 8.3.6 ForkJoin框架的原理
  • 8.4 生产者-消费者模式
  • 8.5 Future模式
  • 第9章 高并发核心模式之异步回调模式
  • 9.1 从泡茶的案例讲起
  • 9.2 join：异步阻塞之闷葫芦
  • 9.2.1 线程的合并流程
  • 9.2.2 调用join()实现异步泡茶喝
  • 9.2.3 join()方法详解
  • 9.3 FutureTask：异步调用之重武器
  • 9.3.1 通过FutureTask获取异步执行结果的步骤
  • 9.3.2 使用FutureTask实现异步泡茶喝
  • 9.4 异步回调与主动调用
  • 9.5 Guava的异步回调模式
  • 9.5.1 详解FutureCallback
  • 9.5.2 详解ListenableFuture
  • 9.5.3 ListenableFuture异步任务
  • 9.5.4 使用Guava实现泡茶喝的实例
  • 9.5.5 Guava异步回调和Java异步调用的区别
  • 9.6 Netty的异步回调模式
  • 9.6.1 GenericFutureListener接口详解
  • 9.6.2 Netty的Future接口详解
  • 9.6.3 ChannelFuture的使用
  • 9.6.4 Netty的出站和入站异步回调
  • 9.7 异步回调模式小结
  • 第10章 CompletableFuture异步回调
  • 10.1 CompletableFuture详解
  • 10.1.1 CompletableFuture的UML类关系
  • 10.1.2 CompletionStage接口
  • 10.1.3 使用runAsync和supplyAsync创建子任务
  • 10.1.4 设置子任务回调钩子
  • 10.1.5 调用handle()方法统一处理异常和结果
  • 10.1.6 线程池的使用
  • 10.2 异步任务的串行执行
  • 10.2.1 thenApply()方法
  • 10.2.2 thenRun()方法
  • 10.2.3 thenAccept()方法
  • 10.2.4 thenCompose()方法
  • 10.2.5 4个任务串行方法的区别
  • 10.3 异步任务的合并执行
  • 10.3.1 thenCombine()方法
  • 10.3.2 runAfterBoth()方法
  • 10.3.3 thenAcceptBoth()方法
  • 10.3.4 allOf()等待所有的任务结束
  • 10.4 异步任务的选择执行
  • 10.4.1 applyToEither()方法
  • 10.4.2 runAfterEither()方法
  • 10.4.3 acceptEither()方法
  • 10.5 CompletableFuture的综合案例
  • 10.5.1 使用CompletableFuture实现泡茶喝实例
  • 10.5.2 使用CompletableFuture进行多个RPC调用
  • 10.5.3 使用RxJava模拟RPC异步回调
展开全部

评分及书评

4.8
9个评分
  • 用户头像
    给这本书评了
    4.0

    结合代码讲得非常仔细，对操作系统的知识也是一个不错的补充。适合使用 PC 这样的大屏幕看

      转发
      评论

    出版方

    机械工业出版社有限公司

    机械工业出版社是全国优秀出版社，自1952年成立以来，坚持为科技、为教育服务，以向行业、向学校提供优质、权威的精神产品为宗旨，以“服务社会和人民群众需求，传播社会主义先进文化”为己任，产业结构不断完善，已由传统的图书出版向着图书、期刊、电子出版物、音像制品、电子商务一体化延伸，现已发展为多领域、多学科的大型综合性出版社，涉及机械、电工电子、汽车、计算机、经济管理、建筑、ELT、科普以及教材、教辅等领域。