JAVA 多线程中的各种问题分析
首先开始之前 须要提及一下前置章节
可能更加深刻理解本节所讲
- JAVA 并发之根底概念篇
- JAVA 并发之过程 VS 线程篇
首先咱们来说一下并发的长处, 依据长处个性, 引出并发该当留神的平安问题
1 并发的长处
技术在提高，CPU、内存、I/O 设施的性能也在一直进步。然而，始终存在一个外围矛盾：CPU、内存、I/O 设施存在速度差别。CPU 远快于内存，内存远快于 I/O 设施。
依据木桶短板实践可知，一只木桶能装多少水，取决于最短的那块木板。程序整体性能取决于最慢的操作——I/O，即单方面进步 CPU 性能是有效的。
为了正当利用 CPU 的高性能，均衡这三者的速度差别，计算机体系机构、操作系统、编译程序都做出了奉献，次要体现为：
- CPU 减少了缓存，以平衡与内存的速度差别；
- 操作系统减少了过程、线程，以分时复用 CPU，进而平衡 CPU 与 I/O 设施的速度差别；
- 编译程序优化指令执行秩序，使得缓存可能失去更加正当地利用。
其中，过程、线程使得计算机、程序有了并发解决工作的能力，它有 两个重要长处：
- 晋升资源利用率
- 升高程序响应工夫
1.1 晋升资源利用率
从磁盘中读取文件的时候，大部分的 CPU 工夫用于期待磁盘去读取数据。在这段时间里，CPU 十分的闲暇。它能够做一些别的事件。通过扭转操作的程序，就可能更好的应用 CPU 资源 , 应用并发形式不肯定就是磁盘 IO, 也能够是网络 IO 和用户输出等, 然而不论是哪种 IO 都比 CPU 和内存 IO 慢的多. 线程并不能进步速度，而是在执行某个耗时的性能时，在还能够做其它的事。多线程使你的程序在解决文件时不用显得曾经卡死.
1.2 升高程序响应工夫
为了使程序的响应工夫变的更短, 应用多线程应用程序也是常见的一种形式将一个单线程应用程序变成多线程应用程序的另一个常见的目标是实现一个响应更快的应用程序。构想一个服务器利用，它在某一个端口监听进来的申请。当一个申请到来时，它去解决这个申请，而后再返回去监听。
服务器的流程如下所述：
public class SingleThreadWebServer {public static void main(String[] args) throws IOException{ServerSocket socket = new ServerSocket(80);
while (true) {Socket connection = socket.accept();
handleRequest(connection);
}
}
}如果一个申请须要占用大量的工夫来解决，在这段时间内新的客户端就无奈发送申请给服务端。只有服务器在监听的时候，申请能力被接管。另一种设计是，监听线程把申请传递给工作者线程(worker thread)，而后立即返回去监听。而工作者线程则可能解决这个申请并发送一个回复给客户端。这种设计如下所述：
public class ThreadPerTaskWebServer {public static void main(String[] args) throws IOException {ServerSocket socket = new ServerSocket(80);
while (true) {final Socket connection = socket.accept();
Runnable workerThread = new Runnable() {public void run() {handleRequest(connection);
}
};
}
}
}这种形式，服务端线程迅速地返回去监听。因而，更多的客户端可能发送申请给服务端。这个服务也变得响应更快。
桌面利用也是同样如此。如果你点击一个按钮开始运行一个耗时的工作，这个线程既要执行工作又要更新窗口和按钮，那么在工作执行的过程中，这个应用程序看起来如同没有反馈一样。相同，工作能够传递给工作者线程（worker thread)。当工作者线程在忙碌地解决工作的时候，窗口线程能够自在地响应其余用户的申请。当工作者线程实现工作的时候，它发送信号给窗口线程。窗口线程便能够更新应用程序窗口，并显示工作的后果。对用户而言，这种具备工作者线程设计的程序显得响应速度更快。
2 并发带来的安全性问题
并发平安是指 保障程序在并发解决时的后果 合乎预期
并发平安须要保障 3 个个性:
原子性:艰深讲就是相干操作不会中途被其余线程烦扰，个别通过同步机制（加锁：sychronized、Lock）实现。
有序性:保障线程内串行语义，防止指令重排等
可见性: 一个线程批改了某个共享变量，其状态可能立刻被其余线程通晓，通常被解释为将线程本地状态反映到主内存上，volatile 就是负责保障可见性的
Ps: 对于 volatile 这个关键字, 须要独自写一篇文章来解说, 后续更新 请继续关注公众号:JAVA 宝典
2.1 原子性问题
晚期,CPU 速度比 IO 操作快很多, 一个程序在读取文件时, 可将本人标记为 ” 休眠状态 ” 并让出 CPU 的使用权, 期待数据加载到内存后, 操作系统会唤醒该过程, 唤醒后就有机会从新取得 CPU 使用权.
这些操作会引发过程的切换, 不同过程间是不共享内存空间的，所以过程要做工作切换就要切换内存映射地址.
而一个过程创立的所有线程，都是共享一个内存空间的，所以线程做工作切换老本就很低了
所以咱们当初提到的 工作切换 都是指 线程切换
高级语言里一条语句, 往往须要多个 CPU 指令实现, 如:
count += 1，至多须要三条 CPU 指令
- 指令 1：首先，须要把变量 count 从内存加载到 CPU 的寄存器；
- 指令 2：之后，在寄存器中执行 +1 操作；
- 指令 3：最初，将后果写入内存（缓存机制导致可能写入的是 CPU 缓存而不是内存）。
原子性问题呈现:
对于下面的三条指令来说，咱们假如 count=0，如果线程 A 在指令 1 执行完后做线程切换，线程 A 和线程 B 依照下图的序列执行，那么咱们会发现两个线程都执行了 count+=1 的操作，然而失去的后果不是咱们冀望的 2，而是 1。
咱们把一个或者多个操作在 CPU 执行的过程中不被中断的个性称为原子性。CPU 能保障的原子操作是 CPU 指令级别的，而不是高级语言的操作符，这是违反咱们直觉的中央。因而，很多时候咱们须要在高级语言层面保障操作的原子性。
2.2 有序性问题
顾名思义，有序性指的是程序依照代码的先后顺序执行。编译器为了优化性能，有时候会改变程序中语句的先后顺序
举个例子:
双重查看创立单例对象, 在获取实例 getInstance() 的办法中，咱们首先判断 instance 是否为空，如果为空，则锁定 Singleton.class 并再次查看 instance 是否为空，如果还为空则创立 Singleton 的一个实例.
public class Singleton {
static Singleton instance;
static Singleton getInstance(){if (instance == null) {synchronized(Singleton.class) {if (instance == null)
instance = new Singleton();}
}
return instance;
}
} 线程 A,B 如果同时调用 getInstance()办法获取实例, 他们会同时查看到 instance 为 null , 这时会将 Singleton.class 进行加锁操作, 此时 jvm 保障只有一个锁上锁胜利, 另一个线程会期待状态; 假如线程 A 加锁胜利, 这时线程 A 会 new 一个实例之后开释锁, 线程 B 被唤醒, 线程 B 会再次加锁此时加锁胜利, 线程 B 查看实例是否为 null, 会发现曾经被实例化, 不会再创立另外一个实例.
这段代码和逻辑看上去没有问题, 但实际上 getInstance()办法还是有问题的, 问题在 new 的操作上, 咱们认为的 new 操作应该是:
1. 分配内存
2. 在这块内存上初始化 Singleton 对象
3. 将内存地址给 instance 变量
然而理论 jvm 优化后的操作是这样的:
1 分配内存
2 将地址给 instance 变量
3 在内存上初始化 Singleton 对象
优化后会导致 咱们这个时候另一个线程拜访 instance 的成员变量时获取对象不为 null 就完结实例化操作 返回 instance 会触发空指针异样。
#### 2.3 可见性问题
一个线程对共享变量的批改，另外一个线程可能立即看到，称为 可见性。
古代多外围 CPU, 每个外围都有本人的缓存, 多个线程在不同的 CPU 外围上执行时, 线程操作的是不同的 CPU 缓存,
线程不平安的示例
上面的代码，每执行一次 add10K() 办法，都会循环 10000 次 count+=1 操作。在 calc() 办法中咱们创立了两个线程，每个线程调用一次 add10K() 办法，咱们来想一想执行 calc() 办法失去的后果应该是多少呢？
class Test {
private static long count = 0;
private void add10K() {
int idx = 0;
while(idx++ < 10000) {count += 1;}
}
public static long getCount(){return count;}
public static void calc() throws InterruptedException {final Test test = new Test();
// 创立两个线程，执行 add() 操作
Thread th1 = new Thread(()->{test.add10K();
});
Thread th2 = new Thread(()->{test.add10K();
});
// 启动两个线程
th1.start();
th2.start();
// 期待两个线程执行完结
th1.join();
th2.join();}
public static void main(String[] args) throws InterruptedException {Test.calc();
System.out.println(Test.getCount());
// 运行三次 别离输入 11880 12884 14821
}
} 直觉通知咱们应该是 20000，因为在单线程里调用两次 add10K() 办法，count 的值就是 20000，但实际上 calc() 的执行后果是个 10000 到 20000 之间的随机数。为什么呢？
咱们假如线程 A 和线程 B 同时开始执行，那么第一次都会将 count=0 读到各自的 CPU 缓存里，执行完 count+=1 之后，各自 CPU 缓存里的值都是 1，同时写入内存后，咱们会发现内存中是 1，而不是咱们冀望的 2。之后因为各自的 CPU 缓存里都有了 count 的值，两个线程都是基于 CPU 缓存里的 count 值来计算，所以导致最终 count 的值都是小于 20000 的。这就是缓存的可见性问题。
循环 10000 次 count+=1 操作如果改为循环 1 亿次，你会发现成果更显著，最终 count 的值靠近 1 亿，而不是 2 亿。如果循环 10000 次，count 的值靠近 20000，起因是两个线程不是同时启动的，有一个 时差。
3 如何保障并发平安
理解保障并发平安的办法, 首先要理解同步是什么:
同步是指在多线程并发访问共享数据时, 保障共享数据在同一时刻只被一个线程拜访
实现保障并发平安有上面 3 种形式:
1. 阻塞同步(乐观锁):
阻塞同步也称为互斥同步, 是常见并发保障正确性的伎俩, 临界区（Critical Sections）、互斥量（Mutex）和信号量（Semaphore）都是次要的互斥实现形式
最典型的案例是应用
synchronized或Lock。互斥同步最次要的问题是线程阻塞和唤醒所带来的性能问题，互斥同步属于一种乐观的并发策略，总是认为只有不去做正确的同步措施，那就必定会呈现问题。无论共享数据是否真的会呈现竞争，它都要进行加锁（这里探讨的是概念模型，实际上虚构机会优化掉很大一部分不必要的加锁）、用户态外围态转换、保护锁计数器和查看是否有被阻塞的线程须要唤醒等操作。
2. 非阻塞同步(乐观锁)
基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就胜利了，否则采取弥补措施（一直地重试，直到胜利为止）。这种乐观的并发策略的许多实现都不须要将线程阻塞，因而这种同步操作称为非阻塞同步
乐观锁指令常见的有：
- 测试并设置（Test-amd-Set）
- 获取并减少（Fetch-and-Increment）
- 替换（Swap）
- 比拟并替换（CAS）
- 加载链接、条件存储（Load-linked / Store-Conditional）
Java 典型利用场景：J.U.C 包中的原子类（基于
Unsafe类的 CAS (Compare and swap) 操作）
3. 无同步
要保障线程平安，不肯定非要进行同步。同步只是保障共享数据争用时的正确性，如果一个办法原本就不波及共享数据，那么天然毋庸同步。
Java 中的 无同步计划 有：
- 可重入代码 – 也叫纯代码。如果一个办法，它的 返回后果是能够预测的，即只有输出了雷同的数据，就能返回雷同的后果，那它就满足可重入性，程序能够在被打断处继续执行，且执行后果不受影响, 当然也是线程平安的。
- 线程本地存储 – 应用
ThreadLocal为共享变量在每个线程中都创立了一个本地正本，这个正本只能被以后线程拜访，其余线程无法访问，那么天然是线程平安的。
4 总结
为了并发的长处 咱们抉择了多线程, 多线程并发给咱们带来了益处 也带来了问题, 解决这些安全性问题咱们抉择加锁让共享数据同时只能进入一个线程来保障并发时数据安全, 这时加锁也为咱们带来了诸多问题 如: 死锁, 活锁, 线程饥饿等问题
下一篇咱们将分析 加锁导致的活跃性问题 尽请期待
关注公众号:java 宝典