线程安全与锁优化

Posted 2020-09-12 OverrideRe

线程安全与锁优化

线程安全

《Java Concurrency In Practice》的作者Brian Goetz对“线程安全”有一个比较恰当的定义：“当多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方法进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的”

java语言中的线程安全

这里讨论的线程安全，现定于多个线程之间存在共享数据访问这个前提，因为如果一段代码根本不会与其它线程共享数据，那么从线程安全角度来看，程序是串行执行还是多线程执行对他来说是完全没有区别的。

不可变

在Java语言中（特指JDK1.5以后，即Java内存模型被修正后的Java语言），不可变（Immutable）的对象一定是线程安全的。只要一个不可变的对象被正确的构建出来（没有发生this引用逃逸的情况），那其外部的可见状态永远也不会改变。“不可变”带来的安全性是最简单和纯粹的。
Java语言中，如果共享数据是一个基本数据类型，那么只要在定义时使用final关键字修饰它就可以保证它是不可变的。如果共享数据是一个对象，那就需要保证对象的行为不会对其状态产生任何影响，或者说对象的方法不会对其内部的数据产生任何影响。保证对象行为不影响自己状态的途径有很多种，其中最简单的就是把对象中带有状态的变量都声明为final。

相对线程安全

相对线程安全就是外面通常意义上讲的线程安全，它需要保证对这个对象单独的操作是线程安全的，我们在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就看需要在调用端使用额外的同步手段来保证调用的正确性。如下面的例子：

package com.overridere.twelve;

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

运行结果如下：

Exception in thread "Thread-400" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 7
    at java.util.Vector.remove(Vector.java:831)
    at com.overridere.twelve.VectorTest$1.run(VectorTest.java:17)
    at java.lang.Thread.run(Thread.java:745)

虽然这里使用到的Vector的remove()和size()方法都是同步的，但是在多线程环境中，如果不在方法调用端做额外的同步措施的话，仍然是不安全的。上面的例子之所以会报错是因为，在线程remove1进入循环后调用vector.remove()方法前这段时间，线程remove2有可能改变了删除了元素，导致序号i已经不再可用，到线程remove1运行到vector.remove()方法的时候就会抛出ArrayIndexOutOfBoundsException。如果要保证这段代码能正确执行下去，可以将两个for循环变成同步代码块，如下所示：

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

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

绝对线程安全

上面的代码不需要变成同步块也能正确运行

线程兼容

线程兼容是指对象本身不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境下可以安全地使用，我们平常说的一个类不是线程安全的大多数是指这一种情况。Java API中大部分的类都属于线程兼容的，如与前面的Vector和HashTable相对应的集合类ArrayList和HashMap等。

线程对立

线程对立是指无论调用端是否采用了同步措施，都无法在多线程环境中并发使用的代码。
一个线程对立的例子是Thread类的suspeng()和resume()方法，如果有两个线程同时持有一个对象，一个尝试中断线程，另一个尝试恢复线程，如果并发进行的话，无论调用时是否进行了同步，目标线程都是存在死锁风险的，如果suspend()中断的线程就是即将要执行resume()的那个线程，那就肯定要产生死锁了。也正是由于这个原因，suspend()和resume()方法以及被JDK声明废弃了。常见的线程对立操作还有System.setIn()、System.setOut()和System.runFinalizersOnExit()等。

线程安全的实现方法

互斥同步

互斥同步（Mutual Exclusion & Synchronization）是常见的一种并发正确性保障手段。同步是指在多个线程并发访问共享数据时，保障共享数据在同一个时刻只被（或者是一些，使用信号量的时候）线程使用。而互斥是实现同步的一种手段，临界区（Critical Section）、互斥量（Mutex）和信号量（Semaphore）都是主要的互斥实现方式。互斥是因，同步是果，互斥是方法，同步是目的。
synchronized
在Java中，最基本的互斥同步手段就是synchronized关键字，synchronized关键字经过编译后会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令，这两个字节码指令都需要一个reference类型的参数来指明要锁定和解锁的对象。如果Java程序中的synchronized明确指定了对象参数，那就是正对性的reference；如果没有明确指定，那就是根据synchronized修饰的是实例方法还是静态方法，去取对应的多少实例或者Class对象来作为锁对象。
根据Java虚拟机规范的要求，在执行monitorenter指令时，首先要尝试获取对象的锁。如果这个对象没被锁定，或者当前线程已经拥有了那个对象的锁，把锁的计数器加1，相应的，在执行monitorexit指令时会将锁计数器减1，当计数器为0时，锁就释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到对象锁被另外一个线程释放为止。
synchronized同步快对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。
同步块在已进入的线程执行完之前，会阻塞后面其它线程的进入。
阻塞和唤醒一个线程都需要操作系统来帮忙，需要从用户态转换到核心态中，因此状态转换需要耗费很多的处理器时间，所以synchronized是Java语言中的一个重量级锁。

ReentrantLock
除了synchronized之外，我们还可以使用java.util.concurrent包中的重入锁（ReentrantLock）来实现同步，在基本用法上两者很相似，不过代码写法上优点区别，一个表现为API层面的互斥锁（lock()和unlock()方法配合try/finally语句来完成），另一个表现为原生语法层面的互斥锁。不过相比synchronized，ReentrantLock增加了一些高级功能，主要有以下三项：等待可中断、可实现公平锁和锁可以绑定多个条件。

• 等待可中断是指当持有锁的线程长时间不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
• 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁；而非公平锁不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。synchronized中的锁是非公平的，ReentrantLock默认情况下是非公平的，但可以通过带布尔值的构造函数要求使用公平锁。
• 绑定多个条件是指一个ReentrantLock对象可以同时绑定多个Condition对象。

非阻塞同步

互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也成为阻塞同步（Blocking Synchronization）。从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出问题。伴随着硬件指令集的发展，我们有了另外一个选择：基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其它线程争用共享数据，那操作就成功了；如果共享数据有争用产生了冲突，那就再采取其它的补偿措施（最常见的的补偿措施就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步（Non-Blocking Synchronization）
关于使用乐观兵法策略需要“硬件指令集的发展”，是因为我们需要操作和冲突检测这两个步骤具有原子性，如果这里再使用互斥同步来保证就失去意义了，所以只能靠硬件来完成这件事情，硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成，这类指令常用的有：

• 测试并设置（Test-and-Set）
• 获取并增加（Fetch-and-Increment）
• 交换（Swwap）
• 比较并替换（Compare-and-Swap，简称CAS）
• 加载链接/条件存储（Load-Linked/Store-Conditional，简称LL/SC）

CAS指令需要有三个操作数，分别是内存位置（在Java中可以简单理解为变量的内存地址，用V表示）、旧的预期值（用A表示）和新值（用B表示）。CAS指令执行时，当且仅当V符合旧预期值A时，处理器才会用新值B更新V的值，否则它就不执行更新，但是无论是否更新了V的值，都会返回V的旧值，上述处理过程是一个原子操作。
将上面一个没解决的问题来看看如何使用CAS操作来避免阻塞同步，代码如下：

package com.overridere.twelve;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * volatile变量自增运算测试
 */
public class VolatileTest {

    public static volatile AtomicInteger race = new AtomicInteger(0);

    public static void increase() {
        race.incrementAndGet();
    }

    private static final int THREADS_COUNT = 20;

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
        // 等待所有累加线程都结束
        while (Thread.activeCount() > 1)
            Thread.yield();

        System.out.println(race);
    }
}

运行结果为：200000
进入incrementAndGet()方法源码看看：

/**
 * Atomically increments by one the current value.
 *
 * @return the updated value
 */
public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

继续查看getAndAddInt源码：

/**
 * Atomically adds the given value to the current value of a field
 * or array element within the given object <code>o</code>
 * at the given <code>offset</code>.
 *
 * @param o object/array to update the field/element in
 * @param offset field/element offset
 * @param delta the value to add
 * @return the previous value
 * @since 1.8
 */
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
    } while (!compareAndSwapInt(o, offset, v, v + delta));
    return v;
}

其中getIntVolatile和compareAndSwapInt都是本地方法
由上面的代码可知，getAndAddInt方法是使用一个循环，如果CAS操作不成功，就一直循环获取值，直到CAS操作成功为止。
尽管CAS看起来很好，但是CAS还存在一个逻辑漏洞：如果一个变量V初次读取的时候是A值，并且在准备复制的时候检查到它仍然是A值，那我们就能说它的值没有被其它线程改变过吗？如果在这段时间内它的值曾经被改成B然后又改成A，那CAS操作就会误认为它没有被改变过。这个漏洞称为CAS操作的“ABA”问题。java.util.concurrent包为了解决这个问题提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量的版本来保证CAS的正确性。不过目前来说这个类比较“鸡肋”，大部分情况下ABA问题不会影响程序并发的正确性，如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效。

无同步方案

同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。
可重入代码（Reentrant Code）：
这种代码也叫作春代码，可以在代码执行的任何时刻中断它，转而去执行另外一段代码，而在控制权返回以后，原来的程序不会出现任何错误。所有的可重入的代码都是线程安全的，但是并不是所有线程安全的代码都是可重入的。
可重入代码有这几个特点：不依赖存储在堆上的数据和公用的系统资源、用到的状态量都是由参数传入、不调用非可重入的方法。
线程本地存储（Thread Local Storage）：如果一段代码所需要的数据必须与其它代码的共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。

锁优化

自旋与自适应自旋

前面说到互斥同步的时候提到了互斥同步对性能最大的影响是阻塞的实现，挂起线程和恢复线程的操作都需要转入内核态来完成，这些操作给系统的并发性能带来了很大的压力。同时，共享数据的锁定状态只会持续很短的一段时间，为了这段时间去挂起和恢复线程并不值得。如果物理机器上有一个以上的处理器，能让两个或以上的线程同时并行执行，我们就可以让后面请求锁的那个线程“稍等一下”，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁。为了让线程等待，我们只需要让线程执行一个忙循环（自旋），这项技术就是所谓的自旋锁。
自旋等待本身虽然避免了线程切换的开销，但是却会占用处理器时间，因此，如果锁被占用的时间很短，自旋等待的效果就会非常好，反之，如果锁被占用的时间很长，那么自旋的线程只会白白消耗处理器资源。因此，自旋等待的时间必须要有一定的限度，如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式去挂起线程了。自旋次数默认是10次，可以使用参数-XX:PreBlockSpin来更改。

在JDK1.6中引入了自适应的自选所。自适应意味着自旋的时间不在固定了，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，name虚拟机就会认为这次自旋也很有可能再次成功，进而它将允许自旋等待持续相对更长的时间。如果对于某个锁自旋很少成功过，那在以后要获取这个锁时将可能省略掉自旋过程。

锁消除

锁消除是指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。当然，出现这种情况大部分都不是程序员自己知道没有共享数据竞争还要求同步的。如下面的代码：

public String concatString(String s1, String s2, String s3) {
    return s1 + s2 + s3;
}

在JDK1.5之前，String类型数据的相加会转换成StringBuffer对象的连续append()操作，JDK1.5以后变成了StringBuilder，JDK1.5之前上面的代码会转换成下面的代码

public String concatString(String s1, String s2, String s3) {
    StringBuffer sb = new StringBuffer ();
    sb.append(s1);
    sb.append(s2);
    sb.append(s3);
    return sb.toString();
}

每个StringBuffer.append()方法中都有一个同步块，锁是sb对象。虚拟机检测对象sb就会发现它的动态作用域被限制在concatString()方法内部。也就是说，sb的所有引用都不会“逃逸”到concatString()方法之外，其它线程无法访问到它，因此，虽然这里有锁，但是可以被安全滴消除掉。

锁粗化

上面的连续append()方法每个方法中都要进行一次加锁，这样倒不如直接将所有连续的append()方法放在一个同步块中，这就是锁粗化。

轻量级锁

要理解轻量级锁必须从HotSpot虚拟机对象（对象头部分）的内存布局开始介绍。HotSpot虚拟机的对象头分为两部分信息，第一部分用于存储对象自身的运行时数据，如哈希码、GC分代年龄等，这部分被称为“Mark Word”，是实现轻量级锁和偏向锁的关键。另一部分用于存储指向方法区对象类型数据的指针，如果是数组的话，还会有一个额外的部分用于存储数组的长度。
在32位的HotSpot虚拟机中对象未被锁定的状态下，Mark Word的32bit空间中的25bit用于寸处对象的哈希码，4bit用于存储对象的分代年龄，2bit用于存储锁标志位，1bit固定为0，在其它状态下对象的存储内容如下：

存储内容	标志位	状态
对象哈希码、对象分代年龄	01	未锁定
指向锁记录的指针	00	轻量级锁定
指向重量级锁的指针	10	膨胀（重量级锁定）
空，不需要记录信息	11	GC标记
偏向线程ID、偏向时间戳、对象分代年龄	01	可偏向

在代码进入同步块的时候，如果此同步对象没有被锁定，虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储对象目前的Mark Word的拷贝（即Displaced Mark Word）。

如果这个更新操作失败了，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果直说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程抢占了。如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁，锁标志的状态值变为“10”，Mark Word中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也要进入阻塞状态。

解锁过程也是通过CAS来进行的，如果对象的Mark Word仍然指向着线程的锁记录，那就用CAS操作把对象当前的Mark Word和线程中复制的Displaced Mark Word替换回来，如果替换成功，整个同步过程就完成了。如果替换失败，说明有其它线程尝试获取该锁，那就要在释放锁的同时，唤醒被挂起的锁。

轻量级锁依据的是“对于绝大部分的锁，在整个同步期间内都是不存在竞争的”这一经验数据。如果没有竞争，就避免了互斥开销，如果存在竞争，不仅有互斥开销，还多了CAS操作的开销。

偏向锁

如果说轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量，那偏向锁就是在无竞争的情况下把整个同步都消除掉，连CAS操作都不做。

偏向锁的意思是这个锁会偏向第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其它的线程获取，则持有偏向锁的线程将永远不需要进行同步。

假设当前虚拟机启用了偏向锁，name，当锁对象第一次被线程获取的时候，虚拟机将会把对象头中的标志位设为“01”，即偏向模式。同时使用CAS操作把获取到这个锁的线程ID记录在对象的Mark Word之中，如果CAS操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行任何同步操作。直到另一个线程去尝试获取这个锁时，偏向模式宣告结束。

根据锁对象目前是否处于被锁定状态，撤销偏向（Revoke Bias）后恢复到未锁定（标志位为“01”）或轻量级锁定（标志位为“00”）的状态，后续的同步操作就如上面介绍的轻量级锁那样执行。状态转换如下图所示：