Java并发编程基础

一、Java为什么要多线程？

为了合理利用 CPU 的高性能，平衡【CPU、内存、I/O 设备】的速度差异，计算机体系结构、操作系统、编译程序都做出了贡献，主要体现为：

1. CPU 增加了缓存，以均衡与内存的速度差异；
2. 操作系统增加了进程、线程，以分时复用 CPU，进而均衡 CPU 与 I/O 设备的速度差异；
3. 编译程序优化指令执行次序，使得缓存能够得到更加合理地利用。

二、Java怎么实现多线程？线程的基本概念

线程实现：Java虚拟机中的线程会被1:1映射到操作系统原生线程，Java语言层面使用Thread类来实现一个线程

线程调度：Java线程调度由操作系统自动完成，开发者可以设置线程优先级、主动让出执行时间，但无法主动获取执行时间。

线程状态：Java语言层面定义了6中线程状态
i. NEW：新建线程且还未执行start方法
ii. RUNNABLE：包含操作系统线程状态的就绪状态与运行中状态
iii. BLOCKED：阻塞等待排它锁时
iv. WAITING：无限期等待状态，需要其他线程唤醒，如执行wait()方法
v. TIMED_WAITING：限期等待，如sleep()方法、带时间参数的wait()方法
vi. TERMINATED：线程终止状态，线程已执行结束

image.png

Thread中提供的操作线程的方法

join()：等待当前线程执行完毕
interrupt():设置中断标志位

设置中断标志位时，如果线程处于WAITING、TIMED_WAITING状态，这时会抛出中断异常。如果线程处于非阻塞状态，就需要我们主动检测并结束线程。

stop()：终止线程 @Deprecated(since="1.2")
yield()：是操作系统线程放弃时间片，从运行中状态切换到就绪状态
sleep()：使线程进入WAITING状态

未来式

Java 2018年创建Loom项目，该项目开发了新的协程方案：纤程(Fiber)

  A light weight or user mode thread* *，scheduled by the Java virtual machine, not the operation system.

a) 解决问题：解决多线程下线程切换带来的性能损耗

线程切换，操作系统需要存储当前线程的上下文数据，并将目标切换线程挂起时的寄存器数据、内存分页等数据恢复回来。

b) 解决方式：纤程由JVM自己调度，纤程切换由JVM来完成调用栈保护、恢复。一个线程内可创建无数个纤程。

三、多线程提高效率的同时带来了哪些问题？

1、安全性问题
CPU 增加了缓存，以均衡与内存的速度差异，每个CPU都有自己的高速缓存，所有CPU又共享同一个主内存，就会导致缓存数据的不一致。

Java内存模型

image.png

(1) 线程对变量的操作都是与工作内存交互
(2) 线程工作内存与主内存的数据交互由JMM定义的原子操作来实现

image.png

Ø JMM中，“线程对变量的操作都是在工作内存中进行”引发的问题——可见性问题

可见性问题示例

image.png

同样，从Java内存模型可以看出，保证不同线程间数据可见性的解决方法：

a) 变量修改后将新值同步回主内存
b) 在读取变量前先从主内存刷新最新值到工作内存

Java中提供的保证可见性的关键字：
a) volatile——新值立即同步到主内存，每次使用从主内存刷新
b) synchronized——对一个变量unlock之前会把变量值同步回主内存
c) final——变量初始化完成后就不会再改变
Happens-Before 规则——前一个操作的结果对后续操作是可见的

Ø Java“编译程序优化指令执行次序” 引发的问题——有序性问题

编译器为了优化性能，有时候会改变程序中语句的先后顺序，例如程序中：“a=6；b=7；”编译器优化后可能变成“b=7；a=6；”

有序性问题示例

image.png

上述代码可能导致getInstance()获取到的实例为null，导致空指针异常

对于instance = new Singleton() 按照Java虚拟机定义的对象初始化步骤应该是：

a) 分配一块内存 M；
b) 在内存 M 上初始化 Singleton 对象；
c) 然后 M 的地址赋值给 instance 变量。

但是实际上优化后的执行路径却是这样的：

a) 分配一块内存 M；
b) 将 M 的地址赋值给 instance 变量；
c) 最后在内存 M 上初始化 Singleton 对象。

同样，Java也提供了关键字来保证有序性:

volatile——禁止指令重排序语义
Synchronized——线程内表现为串行的语义(Within-Thread As-If-Serial)：在同一个处理器中，重排序过的代码看起来依然是有序的

Ø Java多线程中“线程切换” 引发的问题——原子性问题

    *原子性可以理解为一个或者多个操作在 CPU 执行的过程中不被中断的特性*。

原子性问题示例

对于count+=1操作,至少需要三条CPU指令来完成操作：

a) 首先，需要把变量 count 从内存加载到 CPU 的寄存器；
b) 之后，在寄存器中执行 +1 操作；
c) 最后，将结果写入内存（缓存机制导致可能写入的是 CPU 缓存而不是内存）

所以两个线程一起执行可能会导致结果为1，不是2.

image.png

同样，Java也提供了关键字来保证操作的原子性
a) Synchronized同步
b) 并发工具类，如ReentrantLock

2、活跃性问题

一组互相竞争资源的线程因互相等待，导致“永久”阻塞——死锁问题

产生死锁的四个必要条件

a) 互斥条件——共享资源 X 和 Y 只能被一个线程占用
b) 不可剥夺条件——其他线程不能强行抢占线程占有的资源
c) 请求与保持条件——线程T1已经取得共享资源 X，在等待共享资源Y的时候，不释放共享资源X；
d) 循环等待条件——线程T1等待线程T2占有的资源，线程T2等待线程T1占有的资源

死锁示例

image.png

通过jstack查看线程栈信息

image.png

其他活跃性问题——活锁、饥饿

活锁——活锁线程并没有发生阻塞会一直执行，但是线程不能继续，因为它不断重试相同的操作。活锁典型的例子实在一些重试机制中，比如以太网络上，两个基站尝试使用相同的载波发送数据包，包会发生冲突。发生冲突后，稍后都会重发。如果这时他们都是在 1s 后重发，那么他们又会再次发生冲突，一直循环下去，导致数据包永远不能发送。通过随机的等待再发送能够相当有效的避免活锁的发生。

饥饿——指的是线程因无法访问所需资源而无法执行下去的情况。优先级低的线程得到执行的机会很小，就可能发生线程“饥饿”；持有锁的线程，如果执行的时间过长，也可能导致其他线程的“饥饿”问题。

3、性能问题

Java并发包中的API大多都是用于提高并发性能，如果不考虑性能，只考虑安全，Synchronized就够用了

程序代码中可并行处理的比例决定并发处理所能带来的性能上限——Amdahl（阿姆达尔）定律

image.png

其中p代表可并行百分比，n代表处理器核数

从公式可以看出:

如果可并行百分比p为0时，即完全串行化，此时性能比S为1。
如果可并行百分比p为80%，那么并发处理的性能上限为5，即并发处理的性能最高不会超过串行处理的5倍。

从Amdahl定律可以看出，提高程序性能，可以从两方面入手：

1、 提高可并发处理的代码比例，体现到代码中可以通过降低锁粒度、使用无锁算法或数据结构来实现并发安全(如ThreadLocal、读写锁、乐观锁等等，Java并发包中提供了很多这样的API，后续培训详解)
2、 提高处理器核数、增加线程数

Java并发编程——Java为了提升处理效率引入了多线程，同时也引入了很多并发的问题，为了解决并发问题又提供了相关的并发工具类。

四、并发编程基础——管程

管程——一种程序结构概念，它封装了一系列同步操作过程，并提供了多线程互斥访问共享变量的方法。

image.png

管程(Monitor)的组成部分

共享变量——需要进行同步控制保证同一时刻只有一个线程访问
入口等待队列——存放等待锁而block的线程
条件变量等待队列——存放处于wait状态的线程
成员函数——执行入队出队等操作，对共享变量的操作、对外提供的方法等

管程实现并发控制的基本逻辑

1、线程A想要访问共享变量V，先进入入口等待队列。
2、如果共享变量V没有线程访问，则线程A出队，并访问共享变量，执行相关操作
3、如果线程A访问共享变量V时，发生不满足条件变量的情况，则线程A退出对共享变量V的访问，并进入条件变量A对应的等待队列。
4、如果线程B执行操作使条件变量A满足，则线程A会被移出条件变量等待队列，并进入入口等待队列。

Java中的两类锁，Synchronized、Lock都是基于管程的思想实现。