万本电子书0元读

万本电子书0元读

顶部广告

Java高并发核心编程.卷2,多线程、锁、JMM、JUC、高并发设计模式电子书

售       价:¥

纸质售价:¥96.70购买纸书

158人正在读 | 0人评论 6.3

作       者:尼恩

出  版  社:机械工业出版社

出版时间:2021-05-01

字       数:43.4万

所属分类: 科技 > 计算机/网络 > 程序设计

温馨提示:数字商品不支持退换货,不提供源文件,不支持导出打印

为你推荐

  • 读书简介
  • 目录
  • 累计评论(0条)
  • 读书简介
  • 目录
  • 累计评论(0条)
本书聚焦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高并发设计模式的原理和使用。<br/>
目录展开

前言

自序

第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异步回调

累计评论(0条) 0个书友正在讨论这本书 发表评论

发表评论

发表评论,分享你的想法吧!

买过这本书的人还买过

读了这本书的人还在读

回顶部