深入理解java虚拟机——线程安全与锁优化

最新推荐文章于 2023-12-14 00:23:03 发布

ice__cookie

最新推荐文章于 2023-12-14 00:23:03 发布

阅读量549

点赞数

分类专栏： JVM

本文链接：https://blog.csdn.net/ice__cookie/article/details/79105552

版权

JVM 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1. 线程安全

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

线程安全的“安全程度”由强到弱来排序，我们可以将 Java 语言中各种操作共享的数据分为以下 5 类：

1.不可变：不可变的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施。例如，把对象中带有状态的变量都声明为 final，这样在构造函数结束之后，它就是不可变的。

2.绝对线程安全：一个类要达到“不管运行时环境如何，调用者都不需要任何额外的同步措施”通常需要付出很大的，甚至有时候是不切实际的代价。大多数标注自己是线程安全的类都不是绝对的线程安全。比如 Vector，它的 get、add、size等方法都是被 synchronized 修饰的，单独调用时是安全的，但以一些特殊顺序调用一系列的方法时，就不安全了。

 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);
    }
}

上述代码线程不安全，因为如果另一个线程恰好在错误的时间里删除了一个元素，导致序号 i 已经不再可用的话，再用 i 访问数据就会抛出一个 ArrayIndexOutOfBoundsException。如果要保证这段代码能正确执行下去，我们需要把 removeThread 和 printThread 的定义改成如下代码所示：

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.相对线程安全：保证对这个对象单独操作是线程安全的。例如Vector、HashTable、Collections 的 synchronizedCollection() 方法包装的集合等。

4.线程兼容：对象本身并不安全，但可以在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用。Java API 中大部分的类都是属于线程兼容的。

5.线程对立：无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。例如 Thread 类的 suspend() 和 resume() 方法，如果有两个线程同时持有一个线程对象，一个尝试去中断线程，另一个尝试去恢复线程，如果并发进行，无论调用时是否进行了同步，目标线程都是存在死锁风险的。

2. 线程安全的实现

2.1 互斥同步

同步是指在多个线程并发访问共享数据时，保证共享数据在同一时刻只被一个（或者是一些，使用信号量的时候）线程使用。互斥是实现同步的方法。

在 Java 中最基本的互斥同步手段就是 synchronized 关键字，synchronized 关键字经过编译之后，会在同步块的前后形成 monitorenter 和 monitorexit 这两个字节码指令，这两个字节码都需要一个 reference 类型的参数来指明要锁定和解锁的对象。
synchronized 同步块对同一条线程来说是可重入的，不会出现自己锁死自己的问题。同时，同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入。
因为 Java 的线程是映射到操作系统的原生线程之上的，如果要阻塞或唤醒一个线程，都需要操作系统来帮忙完成，需要从用户态转换到核心态，所以 synchronized 是重量级的操作。

除了还可以使用 java.util.concurrent 包中的重入锁（ReentrantLock）来实现同步。ReentrantLock增加了一些高级功能：

等待可中断：正在等待的线程可以选择放弃等待。
可实现公平锁：公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
绑定多个条件：ReentrantLock 对象可以绑定多个 Condition 对象；在 synchronized 中，锁对象的 wait() 和 notify() 或 notifyAll() 方法只可以实现一个隐含条件。

虽然 synchronized 更重一些，但随着 JDK 的发布，synchronized 还有非常大的优化余地。所以 synchronized 可以实现的话，还是推荐使用 synchronized。

2.2 非阻塞同步

互斥同步因为会阻塞线程，所以也称为阻塞同步，开销很大。互斥同步属于悲观的并发策略，认为不同步就会出现问题。随着硬件指令集的发展，出现了非阻塞同步的方法，这是一种乐观并发策略。它采用先行模式，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施（循环重试）。这就避免了线程额度挂起。

实现非阻塞同步，我们需要操作和冲突检测这两个步骤具备原子性，我们通过硬件指令实现：

测试并设置
获取并增加
交换
比较并交换（ Compare-and-Swap，下文称 CAS）
加载链接/条件存储

CAS 指令需要有 3 个操作数，分别是内存位置（在 Java 中可以简单理解为变量的内存地址，用 V 表示）、旧的预期值（用 A 表示）和新值（用 B 表示）。CAS 指令执行时，当且仅当 V 符合旧预期值 A 时，处理器用新值 B 更新 V 的值，否则它就不执行更新，但是无论是否更新了 V 的值，都会返回 V 的旧值，上述的处理过程是一个原子操作。

2.3 无同步方案

若方法不涉及共享数据，那它就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的。

可重入代码：也叫纯代码，可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。所有的可重入代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。
判断一个代码是否具备可重入性：如果一个方法，它的返回结果是可预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的。

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

3. 锁优化

为了在线程之间更高效地共享数据，以及解决竞争问题，从而提高程序的执行效率，JDK 对锁进行了大量的优化措施。

3.1 自旋锁与自适应自旋

自旋锁：如果物理机器上有一个以上的处理器，能让两个或以上的线程同时并行执行，我们就可以让后面请求锁的那个线程“稍等一下”，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁。为了让线程等待，我们只需让线程执行一个忙循环（自旋），这项技术就是所谓的自旋锁。

自适应自旋转：自旋的时间由前一次在同一个锁上的自旋时间及锁的拥有者状态决定。如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也很有可能再次成功，进而它将允许自旋等待持续相对更长的时间。如果对于某个锁，自旋很少成功获得过，那在以后要获取这个锁时将可能省略掉自过程，以避免浪费处理器资源。

3.2 锁消除

锁消除是指虚拟机即时编辑器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。如果在一段代码中，堆上的所有数据都不会逃逸出去从而被其他线程访问到，那就可以把它们当作栈上数据对待，认为它们是线程私有的，同步加锁自然就无须进行。

3.3 锁粗化

如果虚拟机探测到有一串零碎的操作都对同一对象加锁，将会把加锁同步的范围扩展（粗化）到整个操作序列的外部。

3.4 轻量级锁

传统锁使用互斥量实现，开销大。它的目的是在没有多线程竞争的前提下，减少传统锁的开销。前面的对象内存布局中提到过，HotSpot 对象头会存储运行时信息“Mark Word”，其中就包括锁信息。如果线程发现对象当前没有被锁定，将会在栈桢建立一个名为锁记录的空间，存储当前锁对象的“Mark Word”拷贝，然后用 CAS 尝试将对象头中的这部分改为指向该锁记录的指针。如果成功了，就获得了锁，并将“Mark Word”标记为轻量级锁定状态。如果失败了，看占有锁的是不是这个线程本身，是的话，可以继续执行，不是的话，说明产生竞争了，轻量级锁将会膨胀为重量级锁。释放锁同样通过 CAS 操作。可以看出，如果没有多线程竞争，大大提升性能，但是如果竞争出现，在传统锁基础上又绕远了一圈。