本文介绍了Java中线程安全的概念，从不可变对象到线程对立，包括绝对线程安全、相对线程安全、线程兼容和线程对立。详细讨论了synchronized、ReentrantLock、非阻塞同步以及无同步方案，阐述了不同线程安全级别的实现和适用场景。
- 定义
广泛的一种说法是如果一个对象可以安全地被多个线程同时使用，那它就是线程安全的。
严谨的说，当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象是线程安全。
线程安全的代码都必须具备一个特征：代码本身封装了所有必要的正确性保障手段（如互斥同步），令调用者无须关心多线程的问题，更无须自己采取任何措施来保证多线程的正确调用。实际中，这种方式不容易做到，在大多数场景中，我们都会将这个定义弱化一些，即“调用这个对象的行为”限定为“单次调用”，这个定义的其他描述也能够成立的话，我们就可以称它是线程安全。
- java中的线程安全
按照线程安全的“安全程度”由强至弱排序，可以将java中的各种操作共享的数据分为一下5类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。
（1）不可变
在JDK1.5之后，即java内存模型被修正之后，不可变的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，那其外部的可见状态永远也不会改变，永远不会看到它在多个线程之中处于不一致的状态（如final关键字）。
java中，如果共享数据是一个基本数据类型，那么只要在定义时使用final关键字修饰它就可以保证它是不可变的。如果共享数据是一个对象，那就需要保证对象的行为不会对其状态产生任何影响才行。如java.lang.String类的对象，它是一个典型的不可变对象，调用它的subString()、replace()和concat()这些方法都不会影响它原来的值，只会返回一个新构造的字符串对象。
保证对象行为不影响自己状态的途径有很多种，其中最简单的就是把对象中带有状态的变量都声明为final，这样在构造函数结束之后，它就是不可变得，如java.lang.Integer构造函数，它通过将内部状态变量value定义为final来保障状态不变。
/**
* The value of the {@code Integer}.
*
* @serial
*/
private final int value;
/**
* Constructs a newly allocated {@code Integer} object that
* represents the specified {@code int} value.
*
* @param value the value to be represented by the
* {@code Integer} object.
*/
public Integer(int value) {
this.value = value;
}
在java中，符合不可变要求的类型，除了java.lang.String之外，常用的还有枚举类型，以及java.lang.Number的部分子类，如Long和Double等数值包装类型，BigInteger和BigDecimal等大数据类型；但同为Number的子类型的原子类AtomicInteger和AtomicLong则并非不可变的。
（2）绝对线程安全
绝对的线程安全完全满足上面线程安全的定义。java中线程安全的类，大多数都不是绝对的线程安全。如下：
package C;
import java.util.Vector;
public class VectorTest {
private static Vector<Integer> vector = new Vector<Integer>();
public static void main(String[] args) {
while(true){
for(int i=0;i<10;i++){
vector.add(i);
}
Thread removeThread = new Thread(new Runnable() {
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<vector.size();i++){
vector.remove(i);
}
}
});
Thread printThread = new Thread(new Runnable() {
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<vector.size();i++){
System.out.print(vector.get(i));
}
}
});
removeThread.start();
printThread.start();
}
}
}
虽然Vector中的方法都是synchronized修饰同步的，但是在多线程环境中，如果不在方法调用的时候进行额外的同步措施，也会是不安全的。
（3）相对线程安全
相对的线程安全就是我们通常意义上说的线程安全，它需要保证对这个对象单独的操作是线程安全的，在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用的时候使用额外的同步手段来保证调用的正确性。
如上述的Vector在调用的时候需要采取如下同步手段保证正确性：
package C;
import java.util.Vector;
public class VectorTest {
private static Vector<Integer> vector = new Vector<Integer>();
public static void main(String[] args) {
while(true){
for(int i=0;i<10;i++){
vector.add(i);
}
Thread removeThread = new Thread(new Runnable() {
public void run() {
// TODO Auto-generated method stub
synchronized (vector) {
for(int i=0;i<vector.size();i++){
vector.remove(i);
}
}
}
});
Thread printThread = new Thread(new Runnable() {
public void run() {
// TODO Auto-generated method stub
synchronized (vector) {
for(int i=0;i<vector.size();i++){
System.out.print(vector.get(i));
}
}
}
});
removeThread.start();
printThread.start();
}
}
}
java中类似Vector这样相对线程安全的类还有HashTable、Collections的synchronizedCollection()方法包装的集合等。
（4）线程兼容
线程兼容是指对象本身并不是线程安全的，但是可以通过在调用时正确地使用同步手段来保证对象在并发环境中可以安全地使用。平常说的一个类不是线程安全的，觉得多数时候指的是这一种情况。java中大部分类都是属于线程兼容的，如Vector相对应的ArrayList类，HashTable相对应的HashMap类等。
（5）线程对立
线程对立是指无论在调用的时候是否采取了同步措施，采取了怎样的同步措施，都无法在多线程的环境中并发使用的代码。如：Thread类的suspend()方法和resume()方法，如果两个线程同时持有一个线程对象，一个尝试去中断线程，另一个尝试去恢复线程，如果并发执行的话，无论调用时是否进行了同步，目标线程都是存在死锁风险的，如果suspend中断的线程就是即将要执行resume的那个线程，那就肯定要产生死锁了。所以，这两个方法已经被JDK声明废弃了。
- 线程安全的实现方法
线程安全的实现可以是有代码编写来决定，但是虚拟机提供的同步和锁机制也可以起到很重要的作用。
（1）互斥同步
java中同步互斥的最基本的方式就是synchronized关键字，synchronized关键字在编译之后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令，这两个字节码都需要一个reference类型的参数来指明要锁定和解锁的对象。如果java程序中的synchronized明确指定了对象参数，那就是这个对象的reference；如果没有明确指定，那就根据synchronized修饰的是实例方法还是类方法，去获取对应的对象实例或Class对象来作为锁对象。
JVM中，在执行monitorenter指令的时候，首先要尝试获取对象的锁。如果这个对象没被锁定，或者当前线程已经拥有了这个对象的锁，则把锁的计数器加1，相应地，在执行monitorexit指令的时候，将锁的计数器减1。当计数器为0时，锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到对象被另外一个线程释放为止。
synchronized同步块对同一条线程来说是可重入的，不会出现把自己锁死的现象。同步块在已经入的线程执行完之前，会阻塞后面要进入的线程。
java的线程是映射到内核线程上的，如果要阻塞或者唤醒一个线程，都需要操作系统来支持，需要由用户态切到内核态再切回用户态，因此synchronized是重量级操作，有的同步块切换时间会比执行时间还要长。所以一般在开发过程中，只有在必要的情况下才使用synchronized。
除了synchronized之外，还可以使用java.util.concurrent中的重入锁（ReentrantLock）来实现同步。重入锁和synchronized一样，都具有线程重入的特性。但是重入锁比synchronized新增了一些高级功能：等待可中断、可实现公平锁以及锁可以绑定多个条件。
等待可中断：当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助。
公平锁：多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁则不保证这一点，在锁被释放的时候，任何一个等待锁的线程都有机会获得锁。synchronized中的锁是非公平的，而ReentrantLock默认情况下也是非公平的，但是可以通过带布尔值的构造函数要求使用公平锁。
锁绑定多个条件：一个ReentrantLock对象可以绑定多个Condition对象。而synchronized中，锁对象的wait和notify或notifyAll方法可以实现一个隐含的条件，如果要和多余一个的条件关联的时候，就不得不额外地添加一个锁。
JDK1.5的时候Lock要比synchronized效率高很多，并不是说synchronized性能不好，在JDK1.6之后，synchronized被优化，性能基本和Lock持平。因此还是提倡使用synchronized，因为synchronized更原生一点儿。
（2）非阻塞同步
互斥同步最主要的问题是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。从处理方式上来说，这种处理方式是一种悲观的并发策略，总是认为只要不去做正确的同步措施，就会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
随着硬件指令的发展，我们有了另一种选择，基于冲突检测的乐观并发策略。通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（最常见的补偿措施就是不断重复尝试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种操作也称为非阻塞同步。
为什么说乐观并发策略需要“硬件指令集的发展”才能进行呢？因为我们需要操作和冲突检测两个操作具备原子性，靠什么保证呢？如果这里再使用同步互斥来保证就失去了意义，所以只能靠硬件来完成。硬件保证一个语义上看起来需要多次操作的行为只通过一条处理器指令就能完成，这类指令常有如下：测试并设置（Test-and-Set）、获取并增加（Fetch-and-Increment）、交换（Swap）、比较并交换（Compare-and-Swap,CAS）、加载链接/条件存储（Load-Linked/Store-Conditional，LL/SC）。
如CAS指令需要3个操作数，分别是内存位置（V）、旧的预期值（A）和新值（B）。CAS指令执行时，当且仅当V符合旧预期值A时，处理器用新值B更新V的值，否则就不执行更新，并且无论是否更新了V的值，都会返回V的旧值，上述的过程是一个原子操作。
JDK1.5之后，java程序中才可以使用CAS操作，该操作由sun.misc.Unsafe类里面的compareAndSwapInt()和compareAndSwapLong()等几个方法包装提供，虚拟机在内部对这些方法做了特殊处理，即时编译出来的结果就是一条平台相关的处理器CAS指令，没有方法调用的过程。
由于Unsage类不是提供给用户程序调用的类，Unsage.getUnsage()的代码中限制了只有启动类加载器（Bootstrap Classloader）加载的class才能访问它，因此，如果不采用反射手段，只能通过其他的java API来间接使用它，如java.util.concurrent包中的整数原子类，其中的compareAndSet()和getAndIncrement()等方法都是用了Unsage类的CAS操作。
package C;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicTest {
public static AtomicInteger race = new AtomicInteger(0);
public static void increase(){
race.incrementAndGet();
}
private static final int THREADS_COUNT = 20;
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread[] threads = new Thread[THREADS_COUNT];
for(int i=0;i<threads.length;i++){
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<10000;i++){
increase();
}
}
});
threads[i].start();
}
while(Thread.activeCount()>1)
Thread.yield();
System.out.println(race);
}
}
将race由int类型改为AtomicInteger之后，因为AtomicInteger的incrementAndGet的方法是原子性的，所以输出结果是正确的。incrementAndGet方法在一个无限循环中，不断尝试将一个比当前值大1的新值赋给自己。如果失败了，那说明在执行“获取-设置”操作的时候值已经有了修改，于是再次循环进行下一次操作，直到设置成功为止。
（3）无同步方案
要保证线程安全，并不一定要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那就无须进行任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。
可重入代码：这种代码可以在代码执行的任何时刻去中断它，转而去执行另外一段代码，而在控制权返回后，原来的程序并不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入代码都是线程安全的，但是并非所有的线程安全代码都是可重入代码。
可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，也就是线程安全的。
线程本地存储：如果一段代码中所需要的数据必须与其他代码共享，那就看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程内，这样，无须同步也能保证线程之间不出现数据争用的问题。
符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者——消费者”模式）都会将产品的消费过程尽量在一个线程中消费完，其中最重要的一个应用实例就是经典Web交互模型中的“一个请求对应一个服务器线程”的处理方式，这种处理方式的广泛应用使得很多Web服务端应用都可以使用线程本地存储来解决线程安全问题。
java中通过java.lang.ThreadLocal类来实现线程本地存储的功能。每一个线程的Thread对象中都有一个ThreadLocalMap对象，这个对象存储了一组以ThreadLocal.threadLocalHashCode为键，以本地线程变量为值的K-V值对，ThreadLocal对象就是当前线程的ThreadLocalMap的访问入口，每一个ThreadLocal对象都包含了一个独一无二的threadLocalHashCode值，使用这个值就可以在线程K-V值对中召回对应的本地线程变量。
扫一扫
309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
