Java线程安全

前言

　　在软件行业发展的初期，程序编写是以算法为核心的，程序员会把数据和过程分别作为独立的部分来考虑，数据代表问题空间中的客体，程序代码则用于处理这些数据，这种思维的方式直接站在计算机的角度去抽象问题和解决问题，称为面向过程的编程思想。于此相对的是，面向对象的编程思想是站在现实世界的角度去抽象和解决问题，它把数据和行为都看做是对象的一部分，这样可以让程序员能以符合现实世界的思维方式来编写和组织程序。

线程安全

　　线程安全：当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替进行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象是线程安全的。

Java的线程安全

　　按照线程安全的“安全强度”由强到弱来排序，我们可以将Java语言中各种操作共享的数据分为以下5类：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。

（1）不可变（Immutable）

　　在Java语言中（特指JDK1.5以后，即Java内存模型被修正之后的Java语言），不可变对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采用任何的线程安全保障措施。只要一个不可变对象被正确的构建出来（没有发生this引用逃逸的情况），那其外部的可见状态永远不会改变，永远也不会看到它在多线程之中处于不一致的状态。“不可变”带来的安全性是最简单和最纯粹的。

　　在Java语言中，如果共享数据是一个基本数据类型，那么只要在定义时使用final关键字修饰它就可以保证它是不可变的。如果共享数据是一个对象，那就需要保证对象的行为不会对其状态产生任何影响才行。保证对象行为不影响自己状态的途径有很多种，其中最简单的就是把对象中带有状态的变量都声明为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.lang.Integer构造函数，它就是通过将内部状态定义为final来保障状态不变的。

在Java API中符合不可变要求的类型，有：String、枚举类型以及java.lang.Number的部分子类：如Long和Double等数值包装类型，BigInteger和BigDecimal等大数据类型。

（2）绝对线程安全

　　绝对的线程安全完全满足上面定义的线程安全定义。在Java API中标注自己是线程安全的类，大多数都不是绝对的线程安全。下面看一个Vector的例子，来了解这里的“绝对”是什么意思。

 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() {
                @Override
                public void run() {
                    for (int i = 0; i < vector.size();i++){
                        vector.remove(i);
                    }
                }
            });

            Thread printThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0;i < vector.size();i++){
                        System.out.println(vector.get(i));
                    }
                }
            });
            //启动线程
            removeThread.start();
            printThread.start();

            //不要产生过多的线程，否则会导致操作系统假死
            while (Thread.activeCount() > 20);
        }
    }

　　上述代码使用到的Vector的get()、remove()和size()方法都是同步的，但是在多线程的环境中，如果不在方法调用端做额外的同步措施的话，使用这段代码仍然是不安全的，因为如果一个线程恰好在错误的时间里删除了一个元素，导致序号i已经不可再用的话，再用i访问数组就会抛出一个ArrayIndexOutOfBoundsException。如果要保证这段代码能正确执行下去，我们不得不做如下修改：

　　　　　　Thread removeThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (vector){
                        for (int i = 0; i < vector.size();i++){
                            vector.remove(i);
                        }
                    }
                }
            });

            Thread printThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (vector){
                        for (int i = 0;i < vector.size();i++){
                            System.out.println(vector.get(i));
                        } 
                    }
                }
            });

（3）相对线程安全

　　相对的线程安全就是我们通常意义上的线程安全，它需要保证对这个对象单独的操作是线程安全的，我们在调用的时候不需要额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性（（2）中代码就是相对线程安全的示例）。

　　在Java语言中，大部分的线程安全类都属于这种类型：Vector、HashTable、Collections的SynchronizedCollection()方法包装的集合等。

（4）线程兼容

　　线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确的使用同步手段来保证对象在并发环境下可以安全的使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API中大部分的类都是属于线程兼容的。

（5）线程对立

　　线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境下并发使用的代码。由于Java语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应当尽量避免。

　　一个线程对立的例子是Thread类的suspend()和resume()方法，如果两个线程同时持有一个线程对象，一个尝试去中断线程，另一个尝试去恢复线程，如果并发进行的话，无论调用端是否进行了同步，目标线程都是存在死锁风险的。也正是由于这个原因，suspend()和resume()方法已经被JDK声明废弃了。常见的线程对立的操作还有System.setIn()、System.setOut()和System.runFinalizersOnExit()等。

线程安全的实现方法

（1）互斥同步

　　互斥同步是很常见的一种并发正确性保障手段。同步是指在多个线程并发访问共享数据时，保证共享数据在同一时刻只被一个（或者是一些，使用信号量的时候）线程使用。而互斥是实现同步的一种手段，临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）都是主要的互斥实现方式。因此，在这4个字里面，互斥是因，同步是果；互斥是方法。同步是目的。

　　在Java中，最基本的互斥同步手段就是synchronized关键字，synchronized关键字经过编译之后，会在同步块的前后形成monitorenter和monitorexit这两个字节码，这两个字节码都需要一个reference类型的参数来指明要锁定和解锁的对象。如果Java程序中的synchronized明确指定了对象参数，那就是这个对象的reference；如果没有明确指定，那就根据synchronized修饰的是实例方法还是类方法，去取对应的对象实例或Class对象来作为锁对象。

　　除了synchronized之外，还可以使用ReentrantLock来实现同步。可以阅读ReentrantLock和synchronized来了解相应的知识，在这里就不再赘述。

（2）非阻塞同步

　　互斥同步最主要的问题就是进行线程阻塞和唤醒带来的性能问题，因此这种同步也称为阻塞同步。从处理问题的方式上来说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的事情（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。随着硬件指令集的发展，我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗的说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就采用其他的补偿措施，这种乐观的并发策略的许多实现不需要吧线程挂起，因此这种同步操作称为非阻塞同步。

 　　非阻塞同步是通过使用CAS操作来保证共享数据的安全的。具体细节查看CAS（Compare And Swap）。

（3）无同步方案

　　要保证线程安全，并不一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。

　　可重入代码（Reentrant Code）：这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入代码都是线程安全的，但是并非所有线程安全的代码都是可重入的。

　　可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都是由参数中传入、不调用非可重入的方法等。可以通过一个简单的原则来判断代码是否具备可重入性：如果一个方法，它的返回结果是可预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。

　　线程本地存储（Thread Local Storage）：如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程内，这样，无须同步也能保证线程之间不出现数据争用的问题。

　　Java语言中，如果一个变量要被多线程访问，可以使用volatile关键字声明它为“易变的”；如果一个变量要被某个线程独享，可以通过java.lang.ThreadLocal类来实现线程本地存储功能。具体相关ThreadLocal 的知识可以查看ThreadLocal来了解。

 参考：《深入理解Java虚拟机》 周志明 编著：