多线程下对同一变量的操作：从问题到解决方案

于 2025-05-25 17:33:08 发布
阅读量720 收藏 6
点赞数 17
CC 4.0 BY-SA版权
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljysee/article/details/148211211

在 Java 多线程编程中，多个线程同时操作共享变量时，若不进行合理的同步控制，极易引发数据不一致问题。本文将结合具体案例，深入分析多线程环境下操作共享变量的常见问题，并提供基于synchronized和AtomicInteger的解决方案，帮助开发者理解线程安全的核心原理。

一、问题场景：共享变量引发的线程安全问题

1.1 案例复现

假设我们有一个银行账户余额money，需要模拟两个线程同时进行取款操作：

java

public class UnsafeWithdraw {
    private static Integer money = 1000; // 共享变量

    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            money = money - 200; // 线程A取款200
        }, "A取钱");

        Thread threadB = new Thread(() -> {
            money = money - 300; // 线程B取款300
        }, "B取钱");

        threadA.start();
        threadB.start();
    }
}

1.2 问题分析

上述代码看似简单，却存在两个致命问题：

  • 变量可见性问题：Integer是普通对象，未使用volatile修饰，线程间修改可能不会及时同步，导致其他线程读取到旧值。
  • 原子性缺失：money = money - 200由 3 步操作组成（读取、计算、写入），多线程下可能出现指令交错，引发竞态条件（Race Condition）。

例如，若两个线程同时读取到money=1000，各自计算后写入800和700，最终结果可能不是预期的500，而是错误的700或800。

二、解决方案一：使用synchronized保证同步

2.1 原理分析

synchronized关键字通过Monitor 锁机制保证同一时间只有一个线程进入同步块，确保操作的原子性和可见性。

2.2 代码实现

java

public class SynchronizedWithdraw {
    private static Integer money = 1000;

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(() -> {
            synchronized (SynchronizedWithdraw.class) { // 同步锁
                int temp = money;
                temp -= 200;
                money = temp;
                System.out.println(Thread.currentThread().getName() + " 余额：" + money);
            }
        }, "A取钱");

        Thread threadB = new Thread(() -> {
            synchronized (SynchronizedWithdraw.class) { // 同一锁对象
                int temp = money;
                temp -= 300;
                money = temp;
                System.out.println(Thread.currentThread().getName() + " 余额：" + money);
            }
        }, "B取钱");

        threadA.start();
        threadB.start();
        threadA.join(); // 等待线程执行完毕
        threadB.join();
        System.out.println("最终余额：" + money); // 输出500
    }
}

2.3 优缺点

  • 优点：简单直观，适用于复杂同步逻辑（如多个共享变量的操作）。
  • 缺点：高并发下锁竞争会导致性能瓶颈；锁范围需精准控制，避免过度同步。

三、解决方案二：使用AtomicInteger实现无锁原子操作

3.1 核心原理

AtomicInteger位于java.util.concurrent.atomic包中，基于CAS（Compare-And-Swap）机制实现无锁原子操作：

  1. 读取当前值current；
  2. 计算目标值next = current + delta；
  3. 通过CAS比较并更新：若当前值仍为current，则写入next，否则重试。

3.2 常用方法

方法说明示例（初始值为 1000）
addAndGet(delta)先加后返回新值addAndGet(-200) → 800
getAndAdd(delta)先返回旧值再加getAndAdd(-200) → 1000，值变为 800
compareAndSet(expect, update)预期值匹配时更新若当前值为 1000，则更新为 800

3.3 代码实现

java

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicWithdraw {
    private static AtomicInteger money = new AtomicInteger(1000); // 原子变量初始化

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(() -> {
            int newMoney = money.addAndGet(-200); // 原子性取款200
            System.out.println(Thread.currentThread().getName() + " 余额：" + newMoney);
        }, "A取钱");

        Thread threadB = new Thread(() -> {
            int newMoney = money.addAndGet(-300); // 原子性取款300
            System.out.println(Thread.currentThread().getName() + " 余额：" + newMoney);
        }, "B取钱");

        threadA.start();
        threadB.start();
        threadA.join();
        threadB.join();
        System.out.println("最终余额：" + money.get()); // 输出500
    }
}

3.4 优缺点

  • 优点：无锁机制，高并发下性能优于synchronized；API 简洁，适合单个变量的原子操作。
  • 缺点：仅支持单个变量的原子操作；存在 ABA 问题（可通过AtomicStampedReference解决）。

四、补充方案：更多线程安全控制方法

4.1 volatile关键字：保证可见性与有序性

volatile关键字通过强制线程从主内存读取 / 写入变量，确保修改对其他线程的可见性，并禁止指令重排序。
注意：volatile不保证原子性，仅适用于单次读 / 写操作。

java

public class VolatileDemo {
    private static volatile boolean isReady = false; // 状态标记

    public static void main(String[] args) {
        new Thread(() -> {
            while (!isReady) {
                Thread.yield();
            }
            System.out.println("子线程开始执行");
        }, "工作线程").start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        isReady = true; // 主线程修改状态，子线程可见
    }
}

4.2 Lock接口（如ReentrantLock）：灵活锁控制

ReentrantLock是显式锁，支持可中断锁、公平锁、条件变量等高级功能。

java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
    private static Integer money = 1000;
    private static final Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(() -> {
            lock.lock();
            try {
                money -= 200;
                System.out.println("A取钱后余额：" + money);
            } finally {
                lock.unlock(); // 必须在finally中释放锁
            }
        }, "A取钱");

        Thread threadB = new Thread(() -> {
            if (lock.tryLock()) { // 尝试获取锁，避免阻塞
                try {
                    money -= 300;
                    System.out.println("B取钱后余额：" + money);
                } finally {
                    lock.unlock();
                }
            } else {
                System.out.println("B获取锁失败，放弃操作");
            }
        }, "B取钱");

        threadA.start();
        threadB.start();
        threadA.join();
        threadB.join();
    }
}

4.3 原子引用类：AtomicReference与AtomicStampedReference

4.3.1 AtomicReference：对象的原子操作

用于对对象引用的原子更新。

java

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceDemo {
    private static class Account {
        int balance;
        public Account(int balance) { this.balance = balance; }
    }

    private static AtomicReference<Account> accountRef = 
        new AtomicReference<>(new Account(1000));

    public static void main(String[] args) {
        new Thread(() -> {
            Account oldAccount = accountRef.get();
            Account newAccount = new Account(oldAccount.balance - 200);
            while (!accountRef.compareAndSet(oldAccount, newAccount)) {
                oldAccount = accountRef.get();
                newAccount = new Account(oldAccount.balance - 200);
            }
        }, "A取钱").start();
    }
}
4.3.2 AtomicStampedReference：解决 ABA 问题

通过给对象添加版本号，避免 CAS 操作中值被修改后又改回的问题。

java

import java.util.concurrent.atomic.AtomicStampedReference;

public class ABAProblemSolution {
    private static AtomicStampedReference<Integer> money = 
        new AtomicStampedReference<>(1000, 0);

    public static void main(String[] args) {
        int stamp = money.getStamp();
        // 模拟线程A：先减200，再加200（产生ABA问题）
        new Thread(() -> {
            money.compareAndSet(1000, 800, stamp, stamp + 1);
            money.compareAndSet(800, 1000, stamp + 1, stamp + 2);
        }, "A线程").start();

        // 模拟线程B：尝试将1000改为700（实际值未变，但版本号已变）
        new Thread(() -> {
            int currentStamp = money.getStamp();
            while (!money.compareAndSet(1000, 700, currentStamp, currentStamp + 1)) {
                currentStamp = money.getStamp();
            }
            System.out.println("B线程最终余额：" + money.getReference()); // 输出700
        }, "B线程").start();
    }
}

4.4 ThreadLocal：线程封闭（避免共享）

ThreadLocal为每个线程创建变量副本，使变量完全属于当前线程。

java

public class ThreadLocalDemo {
    private static final ThreadLocal<Integer> threadMoney = 
        ThreadLocal.withInitial(() -> 1000);

    public static void main(String[] args) {
        new Thread(() -> {
            int money = threadMoney.get();
            money -= 200;
            threadMoney.set(money);
            System.out.println("A线程余额：" + threadMoney.get()); // 输出800
        }, "A线程").start();

        new Thread(() -> {
            int money = threadMoney.get();
            money -= 300;
            threadMoney.set(money);
            System.out.println("B线程余额：" + threadMoney.get()); // 输出700
        }, "B线程").start();
    }
}

五、全方案对比与选择指南

方案核心机制原子性可见性适用场景典型案例
普通变量无同步不保证不保证单线程环境局部变量
volatile内存屏障 + 禁止重排序单操作保证保证状态标记、单次读写变量isReady、isShutdown
synchronizedMonitor 锁（阻塞式）代码块内保证保证多变量复合操作、复杂同步逻辑账户余额修改（多步骤操作）
AtomicIntegerCAS（无锁）单变量原子操作保证整数加减、计数统计计数器、库存扣减
ReentrantLock显式锁（可重入）自定义范围保证保证可中断锁、公平锁、条件变量资源竞争激烈的临界区
AtomicReferenceCAS（对象引用）对象级原子操作保证对象状态的原子更新链表节点的原子替换
ThreadLocal线程副本（无共享）无共享需求无（线程内可见）线程独立变量（避免共享）数据库连接、用户上下文

六、总结：选择策略与最佳实践

  1. 优先避免共享：能用ThreadLocal隔离变量，就无需同步。
  2. 简单数值操作：直接使用AtomicInteger/AtomicLong。
  3. 复合操作 / 复杂逻辑：使用synchronized或ReentrantLock。
  4. 对象级原子性：用AtomicReference；需防 ABA 问题时，用AtomicStampedReference。
  5. 警惕性能陷阱：高并发下优先尝试无锁方案（CAS）；低并发时选择代码简洁的方案。

通过合理组合这些工具，开发者可以在多线程共享变量的场景中，兼顾线程安全、性能与代码可读性，写出健壮的并发程序。

ljysee
关注
【多线程】（基础二）
haoshaokang_的博客
08-18 1025
线程安全问题：在操作系统的随机调度下 ，多个线程的并发执行会产生多种可能，可能会产生BUG 我们使用两个线程对同一个变量分别自增了5000次，按理来说最后结果应该是10000，下面我们来看结果 a++; 这一行代码对应了三条机器指令：从内存读取数据到CPU（load），在CPU寄存器中完成加法运算（add），把运算结果放到内存中（save）那由于两个线程的执行是调度器随机调度的，所以在某一时刻，这两个线程可能都在CPU的不同核心上运行（并行执行），也可能只有一个在CPU上执行，也可能俩线程都没在CPU上
C++调试经验（1）：多线程操作同一数据一定要加锁
qq_27897937的博客
10-13 516
多线程操作同一个数据一定要加锁，否则有可能引起灾难性问题。
线程安全(上)
qq_61797201的博客
07-29 3189
在多线程中，并不是说知道怎么使用就完事了，学习完如何使用多线程之后，我们了解到多线程的并发性和随机调度的特性是我们程序员不容易控制的，所以一旦操作不当就会带来许多安全问题，那我们就开始学习线程安全吧！.........
多进程常见问题——创建多个线程时访问同一个父线程变量（临界资源）时如何加锁使得共享父线程变量不被重复修改？
qq_59580408的博客
03-23 825
多线程如何进行锁的操作来解决共享资源？
Java并发基础(21)：多个线程读写同一共享变量是否存在并发问题？
mingyuli的博客
09-18 4696
1、
java多线程_java多线程下变量共享_
09-30
Java多线程是Java编程中的重要概念，它允许...理解并掌握Java多线程下变量共享的原理和解决方案，有助于编写出高效、稳定的并发程序。在实际开发中，应结合具体业务场景选择合适的同步机制，以达到最佳性能和安全性。
Java多线程编程常见问题与解决方案
最新发布
05-04
针对这些常见问题，本文将详细介绍相应的解决方案，以帮助读者更好地理解和掌握Java多线程编程的核心技术。 首先，线程安全问题是一个重要的议题。在多线程环境中，多个线程可能会同时访问同一个资源，如果不加以...
浅谈python多线程和多线程变量共享问题介绍
09-17
通过上述示例代码和解释，我们可以清楚地了解到Python多线程的基础使用方法以及在多线程环境下可能出现的问题及其解决方案。在开发涉及多线程的应用时，合理利用多线程可以显著提高程序的性能和响应速度，但同时也...
采用全局变量方式实现多线程的通信
01-05
然而，全局变量并不是多线程通信的理想解决方案，因为它可能导致代码难以理解和维护，以及增加了数据竞争的风险。更推荐的做法是使用线程安全的数据结构，如`CWinThread`类的`m_pumpMsg`成员，或者使用`ATL`库提供的...
线程安全问题分析
weixin_46103589的博客
04-14 2086
文章目录一、抢占式执行二、两个线程修改同一变量三、原子性四、内存可见性五、指令重排序 多线程可以实现并发编程，从而提升效率。但由于多线程的调度的随机性，导致程序出现错误，这就叫做“线程不安全”。如果在多线程的条件下，程序运行的结果和单线程条件下运行的结果是一致的，那么该线程就是安全的。 那么，多线程在哪些情况下会不安全呢？有如何解决这样的不安全问题呢？ 一、抢占式执行 出现线程安全问题的根本问题就是线程的抢占式执行 抢占式执行意思就是，当某个线程正在执行，在就绪队列中有一个更高优先级的任务出现了，当前任务就
C#基本线程同步
热门推荐
04-12 1万+
0 概述上一章我们了解了多个线程可以“同时”运行代码（我们称为“异步运行”），这一章我们来研究为什么异步运行的线程需要同步？所谓同步，就是给多个线程规定一个执行的顺序（或称为时序），要求某个线程先执行完一段代码后，另一个线程才能开始执行。第一种情况：多个线程访问同一个变量：一个线程写，其它线程读：这种情况不存在同步问题，因为只有一个线程在改变内存中的变量，内存中的变量在任意时刻
编写Java程序，实现多线程操作同一个实例变量的操作会引发多线程并发的安全问题。
2401_84003554的博客
04-10 818
在这里，由于面试中MySQL问的比较多，因此也就在此以MySQL为例为大家总结分享。但是你要学习的往往不止这一点，还有一些主流框架的使用，Spring源码的学习，Mybatis源码的学习等等都是需要掌握的，我也把这些知识点都整理起来了一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
精通高并发与多线程，却不会用ThreadLocal？
Cbuc丶的博客
11-08 518
大家好，我是小菜，一个渴望在互联网行业做到蔡不菜的小菜。可柔可刚，点赞则柔，白嫖则刚！ 死鬼~看完记得给我来个三连哦！ 本文主要介绍 ThreadLocal 的使用 如有需要，可以参考 如有帮助，不忘 点赞 ❥ 微信公众号已开启，小菜良记，没关注的同学们记得关注哦！ 之前我们有在并发系列中提到 ThreadLocal 类和基本使用方法，那我们就来看下 ThreadLocal 究竟是如何使用的！ ThreadLocal 简介 概念 ThreadLocal 类是用来提供线程内部的局部变量。这种变量在多线程
c语言多线程访问一个变量_多线程+高并发+操作系统+网络+基础+调优+源码等xmind图整理好了...
weixin_39981681的博客
12-10 1717
前言多线程并发问题，基本是面试必问的。今年刚刚毕业准备找实习的同学或者经历过最近一段时间面试的朋友们，相应你们应该都有一个相同的问题被问到，那就是多线程与高并发因为最近和腾讯、阿里包括字节和京东等一线大厂的面试负责人朋友在聊天的时候，他们给我共同的建议就是在面试的时候都要问一下对于多线程和高并发的理解，因为这些技术的理解决定了他们的项目在做的时候，他们所负责的部分深入到了什么程度。相信说...
对于“多线程访问同一个变量是否需要加锁”的研究
sh542610的专栏
05-04 5546
对于多线程访问同一变量是否需要加锁的问题，先前大家都讨论过。今天用代码验证了一下之前的猜想:32位CPU与内存的最小交换数据为4字节/次，这也是结构体要对齐4字节的原因。在物理上，CPU对于同一4字节的内存单元，不可能写2个字节的同时，又读了3字节。 测试环境为： XEON 2CPU*2 Windows7 采用50,50,50线程交叉读写，试验代码如下： C/C+
解决多线程使用全局变量时需要不断加锁和解锁的问题
思我所
06-03 5478
在多线程编程中，如果多个线程都需要对同一个全局变量进行赋值或者读取操作，那么在每次赋值或读取时，为了确保线程安全，都必须要进行加锁和解锁的操作，这样会在编程时带来很多麻烦。特别是线程多、全局变量多的时候，需要不断地加锁和解锁。 传统的全局变量使用方法如下： global_variables.h: // 1.无人机 extern Drone g_drone; extern std::mutex drone_mutex; // 2.无人车 extern Vehicle g_vehicle; extern st
深入理解多线程编程：从问题到解决方案
线程安全是指代码在多线程环境下正确运行的能力，这通常涉及到同步原语的使用。死锁发生在两个或更多线程互相等待对方释放资源，从而导致所有线程都无法继续执行。优先级反转和资源饥饿则与线程调度和优先级有关，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值