Java 并发性和多线程

内容简介

Java 并发性和多线程 - v1.2

目录

  • 前言
    • 适用人群
      • 学习前提
      • 目录
        • 第 1 章 Java 并发性和多线程介绍
          • Java 的多线程和并发性
          • 第 2 章 多线程的优点
            • 资源利用率更好
              • 程序设计更简单
                • 程序响应更快
                • 第 3 章 多线程的代价
                  • 设计更复杂
                    • 上下文切换的开销
                      • 增加资源消耗
                      • 第 4 章 并发编程模型
                        • 并发模型与分布式系统之间的相似性
                          • 并行工作者
                            • 并行工作者模型的优点
                            • 并行工作者模型的优点
                              • 并行工作者模型的缺点
                                • 共享状态可能会很复杂
                                  • 无状态的工作者
                                    • 任务顺序是不确定的
                                    • 共享状态可能会很复杂
                                      • 无状态的工作者
                                        • 任务顺序是不确定的
                                          • 流水线模式
                                            • 反应器,事件驱动系统
                                              • Actors 和 Channels
                                              • 反应器,事件驱动系统
                                                • Actors 和 Channels
                                                  • 流水线模型的优点
                                                    • 无需共享的状态
                                                      • 有状态的工作者
                                                        • 较好的硬件整合(Hardware Conformity)
                                                          • 合理的作业顺序
                                                          • 无需共享的状态
                                                            • 有状态的工作者
                                                              • 较好的硬件整合(Hardware Conformity)
                                                                • 合理的作业顺序
                                                                  • 流水线模型的缺点
                                                                    • 函数式并行(Functional Parallelism)
                                                                      • 使用那种并发模型最好?
                                                                      • 第 5 章 如何创建并运行 java 线程
                                                                        • 创建 Thread 的子类
                                                                          • 实现 Runnable 接口
                                                                            • 创建子类还是实现 Runnable 接口?
                                                                              • 常见错误:调用 run()方法而非 start()方法
                                                                                • 线程名
                                                                                  • 线程代码举例:
                                                                                  • 第 6 章 竞态条件与临界区
                                                                                    • 竞态条件 & 临界区
                                                                                    • 第 7 章 线程安全与共享资源
                                                                                      • 局部变量
                                                                                        • 局部的对象引用
                                                                                          • 对象成员
                                                                                            • 线程控制逃逸规则
                                                                                            • 第 8 章 线程安全及不可变性
                                                                                              • 引用不是线程安全的!
                                                                                              • 第 9 章 Java 内存模型
                                                                                                • Java 内存模型内部原理
                                                                                                  • 硬件内存架构
                                                                                                    • Java 内存模型和硬件内存架构之间的桥接
                                                                                                      • 共享对象可见性
                                                                                                        • Race Conditions
                                                                                                        • 共享对象可见性
                                                                                                          • Race Conditions
                                                                                                          • 第 10 章 Java 同步块
                                                                                                            • Java 同步关键字(synchronized)
                                                                                                              • 实例方法同步
                                                                                                                • 静态方法同步
                                                                                                                  • 实例方法中的同步块
                                                                                                                    • 静态方法中的同步块
                                                                                                                      • Java 同步实例
                                                                                                                      • 第 11 章 线程通信
                                                                                                                        • 通过共享对象通信
                                                                                                                          • 忙等待(Busy Wait)
                                                                                                                            • wait(),notify()和 notifyAll()
                                                                                                                              • 丢失的信号(Missed Signals)
                                                                                                                                • 假唤醒
                                                                                                                                  • 多个线程等待相同信号
                                                                                                                                    • 不要在字符串常量或全局对象中调用 wait()
                                                                                                                                    • 第 12 章 死锁
                                                                                                                                      • 更复杂的死锁
                                                                                                                                        • 数据库的死锁
                                                                                                                                        • 第 13 章 避免死锁
                                                                                                                                          • 加锁顺序
                                                                                                                                            • 加锁时限
                                                                                                                                              • 死锁检测
                                                                                                                                              • 第 14 章 饥饿和公平
                                                                                                                                                • 下面是本文讨论的主题:
                                                                                                                                                  • Java 中导致饥饿的原因
                                                                                                                                                    • 高优先级线程吞噬所有的低优先级线程的 CPU 时间
                                                                                                                                                      • 线程被永久堵塞在一个等待进入同步块的状态
                                                                                                                                                        • 线程在等待一个本身(在其上调用 wait())也处于永久等待完成的对象
                                                                                                                                                          • 在 Java 中实现公平性
                                                                                                                                                            • 使用锁方式替代同步块
                                                                                                                                                              • 公平锁
                                                                                                                                                                • 性能考虑
                                                                                                                                                                • 第 15 章 嵌套管程锁死
                                                                                                                                                                  • 一个更现实的例子
                                                                                                                                                                    • 嵌套管程锁死 VS 死锁
                                                                                                                                                                    • 第 16 章 Slipped Conditions
                                                                                                                                                                      • 一个更现实的例子
                                                                                                                                                                        • 解决 Slipped Conditions 问题
                                                                                                                                                                        • 第 17 章 Java 中的锁
                                                                                                                                                                          • 一个简单的锁
                                                                                                                                                                            • 锁的可重入性
                                                                                                                                                                              • 锁的公平性
                                                                                                                                                                                • 在 finally 语句中调用 unlock()
                                                                                                                                                                                • 第 18 章 Java 中的读/写锁
                                                                                                                                                                                  • 读/写锁的 Java 实现
                                                                                                                                                                                    • 读/写锁的重入
                                                                                                                                                                                      • 读锁重入
                                                                                                                                                                                        • 写锁重入
                                                                                                                                                                                          • 读锁升级到写锁
                                                                                                                                                                                            • 写锁降级到读锁
                                                                                                                                                                                              • 可重入的 ReadWriteLock 的完整实现
                                                                                                                                                                                                • 在 finally 中调用 unlock()
                                                                                                                                                                                                • 第 19 章 重入锁死
                                                                                                                                                                                                  • 第 20 章 信号量
                                                                                                                                                                                                    • 简单的 Semaphore 实现
                                                                                                                                                                                                      • 使用 Semaphore 来产生信号
                                                                                                                                                                                                        • 可计数的 Semaphore
                                                                                                                                                                                                          • 有上限的 Semaphore
                                                                                                                                                                                                            • 把 Semaphore 当锁来使用
                                                                                                                                                                                                            • 第 21 章 阻塞队列
                                                                                                                                                                                                              • 阻塞队列的实现
                                                                                                                                                                                                              • 第 22 章 线程池
                                                                                                                                                                                                                • 第 23 章 CAS
                                                                                                                                                                                                                  • CAS 的使用场景
                                                                                                                                                                                                                    • CAS 用作原子操作
                                                                                                                                                                                                                    • 第 24 章 剖析同步器
                                                                                                                                                                                                                      • 状态
                                                                                                                                                                                                                        • 访问条件
                                                                                                                                                                                                                          • 状态变化
                                                                                                                                                                                                                            • 通知策略
                                                                                                                                                                                                                              • Test-and-Set 方法
                                                                                                                                                                                                                              • 第 25 章 无阻塞算法
                                                                                                                                                                                                                                • 阻塞并发算法
                                                                                                                                                                                                                                  • 非阻塞并发算法
                                                                                                                                                                                                                                    • 非阻塞算法 vs 阻塞算法
                                                                                                                                                                                                                                      • 非阻塞并发数据结构
                                                                                                                                                                                                                                        • Volatile 变量
                                                                                                                                                                                                                                          • 单个写线程的情景
                                                                                                                                                                                                                                            • 基于 volatile 变量更高级的数据结构
                                                                                                                                                                                                                                              • 使用 CAS 的乐观锁
                                                                                                                                                                                                                                                • 为什么称它为乐观锁
                                                                                                                                                                                                                                                  • 乐观锁是非阻塞的
                                                                                                                                                                                                                                                    • 不可替换的数据结构
                                                                                                                                                                                                                                                      • 共享预期的修改
                                                                                                                                                                                                                                                        • 可完成的预期修改
                                                                                                                                                                                                                                                          • A-B-A 问题
                                                                                                                                                                                                                                                            • A-B-A 问题的解决方案
                                                                                                                                                                                                                                                              • 一个非阻塞算法模板
                                                                                                                                                                                                                                                                • 非阻塞算法是不容易实现的
                                                                                                                                                                                                                                                                  • 使用非阻塞算法的好处
                                                                                                                                                                                                                                                                    • 选择
                                                                                                                                                                                                                                                                      • 没有死锁
                                                                                                                                                                                                                                                                        • 没有线程挂起
                                                                                                                                                                                                                                                                          • 降低线程延迟
                                                                                                                                                                                                                                                                          • 选择
                                                                                                                                                                                                                                                                            • 没有死锁
                                                                                                                                                                                                                                                                              • 没有线程挂起
                                                                                                                                                                                                                                                                                • 降低线程延迟
                                                                                                                                                                                                                                                                                • 第 26 章 阿姆达尔定律
                                                                                                                                                                                                                                                                                  • 阿姆达尔定律定义
                                                                                                                                                                                                                                                                                    • 一个计算例子
                                                                                                                                                                                                                                                                                      • 优化算法
                                                                                                                                                                                                                                                                                        • 优化串行分量
                                                                                                                                                                                                                                                                                        • 优化串行分量
                                                                                                                                                                                                                                                                                          • 运行时间 vs. 加速
                                                                                                                                                                                                                                                                                            • 测量,不要仅是计算