1. 线程安全性

1.1 定义

• 线程安全：当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协调，这个类都能表现出正确的行为，那么就称这个类是线程安全的。
• 线程不安全：如果一个类对象同时可以被多个线程访问，如果不做同步处理，可能表现出线程不安全现象（抛出异常、逻辑错误）。

1.2 原子性

1.2.1 定义

提供了互斥访问，同一时刻（时间段）只能有一个线程对它进行操作。避免脏读：数据读取过程中发生了写操作，数据发生了改变。

1.2.2 实现方法

1.2.2.1 synchronized

同一对象同时只能被 synchronized 一次。

• 修饰动态方法
• 修饰静态方法
• 修饰代码块，synchronized（this）{}
• 修饰代码块，synchronized（引用类型）{}
• 修饰代码块，synchronized（类.class){}

1.2.2.2 ReentrantLock

1.2.2.3 ReentrantReadWriteLock

1.2.2.4 StampedLock

1.2.2.4.1 功能

读写锁虽然实现了读和读的并发，但读写之间是冲突的。

1.2.2.4.2 使用步骤

• 主线程使用 new StampedLock() 方法创建 StampedLock 对象。
• 写前使用 stampedLock.writeLock() 方法加写锁。写锁不会阻塞 tryOptimisticRead() 方法，但会阻塞 readLock（）方法，改变 stamp。
• 读前使用 long stamp = s1.tryOptimisticRead() 方法获取版本号，读取数据。
• 确定版本号是否合法（一致），如果是则直接返回结果。
• 如果不是，则将乐观锁升级为悲观锁，如果对象正在被修改，则本线程挂起。读取，释放读锁，返回结果。

1.2.2.5 CAS

public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

// var1 this
// var2 valueOffset
// var4 1
public final int getAndAddInt(Object var1, long var2, int var4) {
        // var5 变量当前值
        int var5;
        //如果变量当前值
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

// 
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

if (var4 == var1.get(var1,var2)) {
    var4 = var5
    return true;
} else {
    return false;
} 

1.3 可见性

1.3.1 定义

一个线程对主内存的修改可以及时被其他线程观察到，例如取款和余额查询业务。

1.3.2 实现方法

如果没有 violate ,可能当前线程看似完成了赋值操作（即运行到下一步），但数据没同步进主存。

1.4 有序性

1.4.1 定义

一个线程观察其他线程的执行，由于指令重排序的存在，该观察结果一般杂乱无序。

1.4.2 实现方法

1.4.2.1 happens-before 原则

• 同一线程内保证顺序性。
• 解锁（Lock、synchronized）操作 happened-before 加锁操作。
• violate 关键字修饰的变量在逻辑上但写操作，happened-before 随后对该变量的读操作。
• 实现方式：内存屏障。

2. 线程安全策略

2.1 不可变对象

2.1.1 final 关键字

• final 修饰的类不允许继承。
• final 修饰的方法不允许重写。
• final 修饰的变量在定义时必须初始化，后期不能修改，并且该变量在子类中也不能被修改，final 修饰的入参在函数中不能被修改，但 final 修饰对象的成员变量能被修改，修饰的容器内的元素能被修改。
• 针对引用对象，使用 final 定义对象和其成员变量保证不变性。
• 针对容器对象，有两种方式保证不变性：

2.2 线程封闭

2.2.1 ThreadLocal

2.2.1.1 定义

将对象封装到一个线程中，只有该线程能访问该对象。

2.2.1.2 实现步骤

public class Thread implements Runnable {
    ......
    ThreadLocal.ThreadLocalMap threadLocals = null;
    ......

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

2.2.1.3 使用步骤

• 当Controller被调用时，调用RequestHolder的getId()静态方法，getId方法调用ThreadLocal<Long>对象的get方法。
• 定义Filter，调用RequestHolder的add方法将当前线程的id添加进ThreadLocal。
• 定义Interceptor，在完成请求响应后清除数据。
• 注入 Filter 和Interceptor。
• 好处：避免每次都从Request中取用户信息。

2.3 线程安全对象

2.3.1 定义

为了省略对于线程不安全类的并发访问需要进行的同步处理。

2.3.2 实现方法

2.3.2.1

• StringBuilder:线程不安全。
• StringBuffer:线程安全，方法使用synchronized关键字。

2.3.2.2

• SimpleDateFormat:线程不安全。
• DateTimeFormatter:线程安全，joda-time包。

2.3.2.3 AutomicXXX

线程安全,使用 CAS 实现。

2.4 被守护对象

2.4.1 定义

（lock、synchorized）,对于共享变量的修改和读取使用锁或同步机制。

2.4.2 实现方法

参考本文章节 1.2.2。

参考资料

• Java并发编程与高并发解决方案
• Java8 读写锁的改进:StampedLock
• 并发策略-CAS算法