线程安全
在项目开发过程中，我们经常提到线程安全一词。排除问题时常因为线程安全问题导致排查时间加长。
线程安全成为程序员经常挂在嘴边的一个词，这次就来学习下线程安全的相关知识。
概念
当多个线程并发访问一个共享对象时，能够正常且正确的完成，获得在单线程下预期的结果，就说就是线程安全的。
在上述概念中需要关注的是：多线程、并发、共享对象
多线程：线程安全必然是在多线程环境下的，单线程访问就不存在资源的抢夺与同步，也就不存在线程不完全。
并发：并发指的是把CPU时间均匀分成若干，多个执行任务交替使用CPU时间。
共享对象：只有当对象是多个线程共享的，存在着资源竞争时，才会产生线程不安全。资源是单个线程独享则是线程安全的。
分类
线程安全不是一个非此即彼的二元选项，根据线程安全的程度可以将其分为：不可变，绝对线程安全、相对线程安全、线程兼容、线程对立五类。
不可变:
一个不可变对象被构建出来，那么其外部的可见状态永远也不会改变，永远也看不到它在多个线程之中处于不一致的状态。
在Java中，如果共享数据一个基本数据类型，只要在定义时使用final 关键字修饰，即可以保证它是不可变的。
如果共享数据时一个对象，就需要保证对象的行为不会对其状态产生影响。
我们经常用到的String类的对象，就是一个不可变对象。
查看其源码会发现底层是一个被final修饰的char数组，它的substring()等方法并不会修改原来的值，而是返回新构建的对象。
public final class String {
private final char value[];
public String substring(int beginIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = value.length - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}
}
绝对线程安全:
要实现绝对线程安全需要付出很大的代价，甚至是不切实际的代价。
要保证调用者不需要任何的额外的同步措施，在任何运行环境下都可以正常且正确的调用。
在Java中的线程安全的类，如我们熟知的Vector,Hashtable等类使用synchronized关键字修饰来保证线程安全，但是它们也不是绝对线程安全。
相对线程安全:
我们通常所说的线程安全就是相对线程安全， 保证对对象的单独的操作是线程安全的，但是在特定顺序调用是要在调用方是额外的同步手段来保证正确性。 例如如下对Vector的使用：
public class TestVector {
private static Vector<Integer> vector = new Vector<>();
public static void main(String[] args) {
while (true){
//向vector插入数据
for (int i = 0; i < 10; i++){
vector.add(i);
}
Thread removeThread = new Thread(new Runnable() {
@Override
public void run() {
//删除vector数据
for (int i = 0; i < vector.size(); i++) {
vector.remove(i);
}
}
});
Thread printThread = new Thread(new Runnable() {
@Override
public void run() {
//获取vector数据
for (int i = 0; i < vector.size(); i++) {
System.out.println(Thread.currentThread().getName()+" " + vector.get(i));
}
}
});
removeThread.start();
printThread.start();
//防止产生过多线程
while (Thread.activeCount() > 10);
}
}
}
使用上述的代码测试会报如下的错误：
Vector的remove()、size()、get()都使用了synchronized关键字修饰，但是依然产生线程安全问题。我们需要在调用方使用的同步方法保证正确性：
public class TestVector {
private static Vector<Integer> vector = new Vector<>();
public static void main(String[] args) {
while (true){
//向vector插入数据
for (int i = 0; i < 10; i++){
vector.add(i);
}
Thread removeThread = new Thread(new Runnable() {
@Override
public void run() {
synchronized (vector) {
//删除vector数据
for (int i = 0; i < vector.size(); i++) {
vector.remove(i);
}
}
}
});
Thread printThread = new Thread(new Runnable() {
@Override
public void run() {
synchronized (vector) {
//获取vector数据
for (int i = 0; i < vector.size(); i++) {
System.out.println(vector.get(i));
}
}
}
});
removeThread.start();
printThread.start();
//防止产生过多线程
while (Thread.activeCount() > 10);
}
}
}
线程兼容:
指对象本身就不是线程安全的，但是我们在调用方使用同步手段保证其在多线程并发环境下的正确性。
我们通常所有的线程不安全就是指的这种情况。我们可以通过编程手段来规避问题。
线程对立:
指的是对象本身不是线程安全的，同时也无法在调用端使用同步手段来保证在多线程并发环境下的正确性。
在Java中的很少出现这种情况。Thread类中的suspend()和resume()方法就是典型的线程对立的例子。
当两个线程并发访问这个对象，分别执行这两个方法：一个中断线程，一个恢复线程。这就存在死锁风险，使用同步方法也无法解决。
实现方案
导致线程安全问题的原因：
• 多线程对共享资源的并发访问（主要是修改）；
• 多线程的调度顺序随机，操作系统的抢占式调度，导致对共享资源访问的随机性；
• 修改变量操作的非原子性，导致操作期间可能被其他线程抢占，从而受到的影响；
• 内存数据的可见性，线程对变量的修改可能在其他线程中不可见，导致数据不一致；
• 虚拟机优化后的指令重排，导致操作的时序问题，从而引起不一致或者覆盖。
根据不同的原因，从而有不同的方案来决解决线程安全的问题。
互斥同步
悲观阻塞
互斥同步保证在多线程并发环境下，共享数据在同一时刻只能被被一个线程使用。
常用的互斥方法有临界区、互斥量、信号量、锁、synchronized关键字的同步块等。
上述这些方法都是先假设当前的操作会导致线程安全问题，先锁定资源，再执行。类似MySQL事务详解（三）：脏写与幻读的绝路—锁一文中提到的悲观锁。
乐观非阻塞
有悲观就有乐观。再乐观策略下，先进行操作，如果产生了冲突，就采取了补偿策略。
在乐观策略下，不需要类似悲观下的阻塞线程，从而提高系统的性能。
在Java中的原子类就是一个乐观策略的例子。基于CAS操作的原子性，从而规避线程安全问题。
非同步
在共享数据存在竞争的情况下，使用同步策略来保证线程安全。如果能够做到数据不存在竞争，无需同步即可保证正确性。
可重入代码：该代码的返回结果是可预测的，相同的输入必然产生相同的结果，即为线程安全。
线程本地存储：Java中的ThreadLocal对象，将共享数据限制在同一个线程之内，保证不出现竞争，即为线程安全。
既然已经看到这里，请随手点个赞吧。
