java 中 i++ 到底是否线程安全?

本文涉及的产品
云数据库 Tair(兼容Redis),内存型 2GB
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
Redis 开源版,标准版 2GB
推荐场景:
搭建游戏排行榜
简介: 本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先,使用 100 个线程分别执行 10000 次 `i++` 操作,发现最终结果小于预期的 1000000,证明 `i++` 是线程不安全的。接着,介绍了两种解决方法:使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中,`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后,通过分析字节码和源码,解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。

先测试下 i++ 是否安全

用100个线程,每个线程支持 10000 次 i++。

java

代码解读

复制代码

/**
 * 用户 100个虚拟线程
 * 给 i 做一万次 i++
 */
@Test
public void demo() throws Exception {
    i = 0;
    // 用来等待所有线程执行完毕
    CountDownLatch countDownLatch = new CountDownLatch(100);
    for (int j = 0; j < 100; j++) {
        // 启动虚拟线程 性能比线程好
        Thread.startVirtualThread(() -> {
            for (int k = 0; k < 10000; k++) {
                i++;
            }
            countDownLatch.countDown();
        });
    }
    // 等待所有线程执行完毕
    countDownLatch.await();
    // 如果线程安全 则会输出 1000000,实际上会小于 1000000
    log.info("结果是:{}", i);
    Assertions.assertTrue(i < 1000000);
}

输出结果:

text

代码解读

复制代码

 结果是:78382

最终看到 只是输出了 78382 ,小于我们期望的 1000000,可见 i++ 是线程不安全的。

那怎么才能线程安全呢?

用 synchronized 加锁实现线程安全

很多同学也想到了用 synchronized 加锁实现线程安全,对的加完锁,我们就实现了线程安全。

java

代码解读

复制代码

/**
 * 用户 100个虚拟线程
 * 给 i 做一万次 i++
 * 加上synchronized 锁
 */
@Test
public void threadSafeSynchronized() throws Exception {
    i = 0;
    // 用来等待所有线程执行完毕
    CountDownLatch countDownLatch = new CountDownLatch(100);
    for (int j = 0; j < 100; j++) {
        // 启动虚拟线程 性能比线程好
        Thread.startVirtualThread(() -> {
            for (int k = 0; k < 10000; k++) {
                synchronized (IppTest.class) {
                    i++;
                }
            }
            countDownLatch.countDown();
        });
    }
    // 等待所有线程执行完毕
    countDownLatch.await();
    // 加了锁以后可以正常的输出 1000000
    log.info("结果是:{}", i);
    Assertions.assertEquals(1000000, i);
}

输出结果:

text

代码解读

复制代码

结果是:1000000

synchronized 实际上对每一个操作都加了锁,所以性能不太好,其他还有什么更好的办法呢?

用 AtomicInteger 来 实现 i++ 线程安全

jdk 自带的一个类 AtomicInteger 专门为我们这种情况提供的,上源码:

java

代码解读

复制代码

    /**
 * 用户 100个虚拟线程
 * 给 atomicInteger 做一万次 累加
 */
@Test
public void threadSafeAtomicInteger() throws Exception {
    atomicInteger = new AtomicInteger(0);
    // 用来等待所有线程执行完毕
    CountDownLatch countDownLatch = new CountDownLatch(100);
    for (int j = 0; j < 100; j++) {
        // 启动虚拟线程 性能比线程好
        Thread.startVirtualThread(() -> {
            for (int k = 0; k < 10000; k++) {
                atomicInteger.incrementAndGet();
            }
            countDownLatch.countDown();
        });
    }
    // 等待所有线程执行完毕
    countDownLatch.await();
    // 加了锁以后可以正常的输出 1000000
    log.info("结果是:{}", atomicInteger.get());
    Assertions.assertEquals(1000000, atomicInteger.get());
}

输出结果:

text

代码解读

复制代码

结果是:1000000

i++ 为什么是线程不全的呢?

首先给我们的编辑器IntelliJ IDEA 安装一个插件 ASM Bytecode Viewer 专门用来看直接码的。

然后我们写一个简单的代码:

java

代码解读

复制代码

    public static void main(String[] args) {
    int i = 0;
    System.out.println("--1--");
    // IINC 1 1  将指定int型变量增加指定值 线程不安全
    i++;
    System.out.println("--2--");
    //ILOAD 1 将指定的int型本地变量推送至栈顶	
    //ICONST_1 将int型1推送至栈顶	
    //IADD 将栈顶两int型数值相加并将结果压入栈顶	
    //ISTORE 1 	将栈顶int型数值存入指定本地变量
    i = i + 1;
    System.out.println("--3--");
}

右键 ASM Bytecode Viewer 我们可以看到对对应的字节码了:

红色框框的部门就是我们对应的字节码。

可见 i++IINC 1 1 操作,是直接对内存中的值进行操作,不是线程安全的。

i = i + 1 和  i++ 还不一样,分了4步,所以也是线程不安全的。

AtomicInteger 为什么是线程安全的?

我们直接上源码: java.util.concurrent.atomic.AtomicInteger.getAndIncrement 返回值,然后自增

java

代码解读

复制代码


/**
 * Atomically increments the current value,
 * with memory effects as specified by {@link VarHandle#getAndAdd}.
 *
 * <p>Equivalent to {@code getAndAdd(1)}.
 *
 * @return the previous value
 */
// 返回值 然后自增
public final int getAndIncrement() {
    // 调用 Unsafe 方法 的 getAndAddInt
    return U.getAndAddInt(this, VALUE, 1);
}

java.util.concurrent.atomic.AtomicInteger.getAndIncrement 返回值,然后自增

这里注意 VALUE 他实际上记录的是 value 这个成员变量,在 当前对象中的内存偏移地址。这个是固定的。

java

代码解读

复制代码


// 内存偏移地址
// objectFieldOffset 返回指定的变量在所属类中的内存偏移地址,该偏移地址仅仅在该Unsafe函数中访问指定字段时使用。
private static final long VALUE
    = U.objectFieldOffset(AtomicInteger.class, "value");

// 用 volatile 修饰的一个值
// 核心为了保障可见性 ,可见性是指当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。
private volatile int value;

/**
 * Atomically increments the current value,
 * with memory effects as specified by {@link VarHandle#getAndAdd}.
 *
 * <p>Equivalent to {@code getAndAdd(1)}.
 *
 * @return the previous value
 */
// 返回值 然后自增
public final int getAndIncrement() {
    // 调用 Unsafe 方法 的 getAndAddInt
    return U.getAndAddInt(this, VALUE, 1);
}

jdk.internal.misc.Unsafe.getAndAddInt 给一个值加上一个值,返回原来的值

java

代码解读

复制代码

    /**
 * Atomically adds the given value to the current value of a field
 * or array element within the given object {@code o}
 * at the given {@code offset}.
 *
 * @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
 */
@IntrinsicCandidate
// 给一个值加上一个值,返回原来的值
// o 对象
// offset 指定值在对象中的偏移量
// delta 加上多少值
// 返回加上以后的值
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        // 不断的根据 对象+内存偏移量 来获取最新的值
        v = getIntVolatile(o, offset);
        //  不断的尝试修改  对象 o 偏移 offset 存储在内存的值 为 v + delta ,直到修改成功
    } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    return v;
}

jdk.internal.misc.Unsafe.weakCompareAndSetInt 也就是我们经常说的 cas 操作,实际上是不断的尝试修改值。

java

代码解读

复制代码


@IntrinsicCandidate
public final boolean weakCompareAndSetInt(Object o, long offset,
    int expected,
    int x) {
    // o 对象
    // offset 指定值在对象中的偏移量
    // expected 期望的原始值
    // x 期望的新值
    // 判断对象 o 偏移 offset 存储在内存的值是否是  expected, 如果是则将 x 放入到内存 返回true
    // 如果内存的值是不是  expected ,则不放到内存 ,然后返回false
    return compareAndSetInt(o, offset, expected, x);
}

可以看到 AtomicInteger 核心是利用了 cas 不断的尝试修改值,并没有加任何锁,所以性能好,也确保了线程安全。

总结

今天带大家深入了解 i++ 的原理,大家可以回去复习下,自己实战过的知识才是自己的。


转载来源:https://juejin.cn/post/7395862170561740850

相关文章
|
22天前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区,如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等,并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比,直观展示了正确与错误的实现方式,旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
|
24天前
|
安全 Java UED
深入浅出Java多线程编程
【10月更文挑战第40天】在Java的世界中,多线程是提升应用性能和响应能力的关键。本文将通过浅显易懂的方式介绍Java中的多线程编程,从基础概念到高级特性,再到实际应用案例,带你一步步深入了解如何在Java中高效地使用多线程。文章不仅涵盖了理论知识,还提供了实用的代码示例,帮助你在实际开发中更好地应用多线程技术。
41 5
|
13天前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景,并结合代码示例和实用技巧,帮助开发者有效避免这些陷阱,提升并发程序的稳定性和性能。 ####
|
11天前
|
存储 监控 小程序
Java中的线程池优化实践####
本文深入探讨了Java中线程池的工作原理,分析了常见的线程池类型及其适用场景,并通过实际案例展示了如何根据应用需求进行线程池的优化配置。文章首先介绍了线程池的基本概念和核心参数,随后详细阐述了几种常见的线程池实现(如FixedThreadPool、CachedThreadPool、ScheduledThreadPool等)的特点及使用场景。接着,通过一个电商系统订单处理的实际案例,分析了线程池参数设置不当导致的性能问题,并提出了相应的优化策略。最终,总结了线程池优化的最佳实践,旨在帮助开发者更好地利用Java线程池提升应用性能和稳定性。 ####
|
13天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####
|
7天前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱,并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手,逐步深入到具体的代码示例,帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者,都能从中获得有价值的见解和建议。 ####
|
7天前
|
Java 调度
Java中的多线程编程与并发控制
本文深入探讨了Java编程语言中多线程编程的基础知识和并发控制机制。文章首先介绍了多线程的基本概念,包括线程的定义、生命周期以及在Java中创建和管理线程的方法。接着,详细讲解了Java提供的同步机制,如synchronized关键字、wait()和notify()方法等,以及如何通过这些机制实现线程间的协调与通信。最后,本文还讨论了一些常见的并发问题,例如死锁、竞态条件等,并提供了相应的解决策略。
24 3
|
8天前
|
监控 Java 开发者
深入理解Java中的线程池实现原理及其性能优化####
本文旨在揭示Java中线程池的核心工作机制,通过剖析其背后的设计思想与实现细节,为读者提供一份详尽的线程池性能优化指南。不同于传统的技术教程,本文将采用一种互动式探索的方式,带领大家从理论到实践,逐步揭开线程池高效管理线程资源的奥秘。无论你是Java并发编程的初学者,还是寻求性能调优技巧的资深开发者,都能在本文中找到有价值的内容。 ####
|
13天前
|
缓存 Java 开发者
Java多线程并发编程:同步机制与实践应用
本文深入探讨Java多线程中的同步机制,分析了多线程并发带来的数据不一致等问题,详细介绍了`synchronized`关键字、`ReentrantLock`显式锁及`ReentrantReadWriteLock`读写锁的应用,结合代码示例展示了如何有效解决竞态条件,提升程序性能与稳定性。
39 5
|
11天前
|
监控 Java 数据库连接
Java线程管理:守护线程与用户线程的区分与应用
在Java多线程编程中,线程可以分为守护线程(Daemon Thread)和用户线程(User Thread)。这两种线程在行为和用途上有着明显的区别,了解它们的差异对于编写高效、稳定的并发程序至关重要。
21 2