【JavaEE】线程安全性问题，线程不安全是怎么产生的，该如何应对

已于 2024-08-24 19:44:10 修改
阅读量8.8k 收藏 130
点赞数 149
分类专栏： JavaEE 文章标签： java-ee 线程安全 操作系统
于 2024-08-23 23:28:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yican2580/article/details/141463585
版权

产生线程不安全的原因

在Java多线程编程中，线程不安全通常是由于多个线程同时访问共享资源而引发的竞争条件。以下是一些导致线程不安全的常见原因：

  1. 共享可变状态：当多个线程对共享的可变数据进行读写时，如果没有适当的同步机制，可能导致数据的不一致性。例如，两个线程同时修改一个共享变量，最终的结果可能取决于线程的执行顺序。

  2. 缺乏同步：在没有使用synchronized关键字或其他同步机制（如Lock）进行保护的情况下，多个线程可以同时进入临界区，从而导致线程安全问题。

  3. 指令重排序：为了提高执行效率，Java虚拟机和处理器可能会对指令进行重排序，这种行为在多线程环境中可能导致不可预期的结果，尤其是在多个线程依赖某些变量的状态时。

  4. 原子性问题：某些操作在Java中并不是原子的，例如对对象属性的读-改-写操作。在多线程环境下，这类操作必须通过同步处理以确保原子性。

  5. 死锁：尽管死锁本身不直接导致线程不安全，但在复杂的同步情况下，死锁可能导致某些线程无法继续执行，从而影响整体程序的正确性与稳定性。

  6. 不可见性：当一个线程对共享变量的修改在其他线程中不可见时，可能导致一些线程读取到过时的值。这通常可以通过使用volatile关键字来解决。

产生线程不安全的案例以及应对方法

共享可变状态案例

我们将创建一个简单的银行账户类，多个线程并发访问该账户进行存款和取款操作。假设我们有两个线程同时对账户进行操作，可能会出现余额计算错误的情况。

class BankAccount {
    private int balance = 100; // 初始余额为100

    public void deposit(int amount) {
        balance += amount; // 存款
    }

    public void withdraw(int amount) {
        balance -= amount; // 取款
    }

    public int getBalance() {
        return balance; // 返回当前余额
    }
}

public class UnsafeBank {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();

        // 创建两个线程同时操作
        Thread t1 = new Thread(() -> {
            account.withdraw(50);
            System.out.println("Thread 1 withdrew 50, balance: " + account.getBalance());
        });

        Thread t2 = new Thread(() -> {
            account.deposit(30);
            System.out.println("Thread 2 deposited 30, balance: " + account.getBalance());
        });

        t1.start();
        t2.start();
    }
}

运行情况： 

我们期望的运行结果是：取款50，余额50、存款30，余额80。但是上述结果并不是我们想要的

分析

在上述代码中，两个线程同时对balance变量进行操作，可能导致不一致的余额输出。例如，假设Thread 1先读取了余额为100，然后进行了取款操作，但在它更新余额之前，Thread 2可能已经读取了余额并进行了存款操作。最终的结果可能不符合预期。

解决方法

为了解决这个线程不安全的问题，我们可以使用synchronized关键字来确保对共享资源的访问是线程安全的。我们可以对deposit和withdraw方法加锁，使得同一时间只有一个线程能够执行其中一个方法。

以下是修改后的代码：

class BankAccount {
    private int balance = 100; // 初始余额为100

    // 存款操作
    public synchronized void deposit(int amount) {
        balance += amount; // 存款
    }

    // 取款操作
    public synchronized void withdraw(int amount) {
        balance -= amount; // 取款
    }

    // 返回当前余额
    public int getBalance() {
        return balance; // 返回当前余额
    }
}

public class SafeBank {
    public static void main(String[] args) throws InterruptedException {
        BankAccount account = new BankAccount();

        // 创建两个线程同时操作
        Thread t1 = new Thread(() -> {
            account.withdraw(50);
            System.out.println("Thread 1 withdrew 50, balance: " + account.getBalance());
        });

        Thread t2 = new Thread(() -> {
            account.deposit(30);
            System.out.println("Thread 2 deposited 30, balance: " + account.getBalance());
        });

        t1.start();
        t2.start();

        // 等待两个线程结束
        t1.join();
        t2.join();
        
        // 输出最终余额
        System.out.println("Final balance: " + account.getBalance());
    }
}

结果

在修改后的代码中，由于对deposit和withdraw方法加了synchronized修饰，确保任何时刻只有一个线程可以执行这两个方法，从而避免了由于竞争条件导致的不一致性。最终输出的余额将与预期结果相一致。

指令重排序案例

指令重排序是指在编译、优化或CPU执行过程中，代码的执行顺序被改变。

count++ 操作并不是一个原子操作，它是由三个步骤组成的：

  1. 读取当前的值。
  2. 对值加1。
  3. 将新值写回。

在多线程环境中，多个线程可能会同时对同一变量进行 count++ 操作，导致结果不正确。这种情况下，指令重排序可能导致某些操作无法达到预期结果。

以下是一个示例代码，演示了这个问题：

class Counter {
    private int count = 0;

    public void increment() {
        count++; // 不安全的操作
    }

    public int getCount() {
        return count;
    }
}

public class CountExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        
        Thread[] threads = new Thread[10];
        
        // 创建10个线程
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increment(); // 增加计数
                }
            });
        }
        
        // 启动所有线程
        for (Thread thread : threads) {
            thread.start();
        }

        // 等待所有线程结束
        for (Thread thread : threads) {
            thread.join();
        }

        // 输出最终计数
        System.out.println("Final count: " + counter.getCount());
    }
}

运行结果： 

我们的预期结果是：10000

分析

在上述代码中，我们创建了10个线程，每个线程执行1000次 increment() 方法，从而期望最终的计数是10000。然而，由于 count++ 操作的非原子性，在多个线程并发执行时，可能会导致某些增量操作丢失，最终结果可能小于10000。

解决方法

为了解决这个问题，可以使用以下几种方法：

  1. 使用synchronized关键字：将increment方法同步，以确保同一时刻只有一个线程能执行该操作。

  2. **使用AtomicInteger**：Java提供了原子类AtomicInteger，能够保证对整数操作的原子性。

我们将采用第二种方法，即使用 AtomicInteger 来解决这个问题。

以下是修改后的代码：

import java.util.concurrent.atomic.AtomicInteger;

class Counter {
    private AtomicInteger count = new AtomicInteger(0); // 使用AtomicInteger

    public void increment() {
        count.incrementAndGet(); // 原子性增加
    }

    public int getCount() {
        return count.get(); // 获取当前值
    }
}

public class SafeCountExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        
        Thread[] threads = new Thread[10];
        
        // 创建10个线程
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increment(); // 增加计数
                }
            });
        }
        
        // 启动所有线程
        for (Thread thread : threads) {
            thread.start();
        }

        // 等待所有线程结束
        for (Thread thread : threads) {
            thread.join();
        }

        // 输出最终计数
        System.out.println("Final count: " + counter.getCount());
    }
}

不可见性案例 

我们使用了两个线程 t1 和 t2。线程 t1 负责不停地检查一个共享变量 fag，而线程 t2 则在休眠1秒后将 fag 设为1。

public class Main {
    public static int fag = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (fag == 0) {

            }
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            fag = 1;
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("主线程结束");
    }
}

 分析

在Java中，fag 是一个共享的静态变量，初始值为0。线程 t1 在一个循环中不断检查 fag 的值，而线程 t2 在休眠1秒后将 fag 更新为1。根据Java内存模型的规定，线程可以在运行过程中缓存某些变量，以提高性能。这意味着，线程 t1 可能在自己的工作内存中读取到fag的值，并且不会每次都去主内存中检查当其值变化时。

因此，虽然 t2 可能已经将 fag 设置为1，但如果 t1 线程没有看到这个变化，它仍然可能会在其循环中继续查看到 fag 为0，导致 t1 线程陷入死循环，程序执行不会继续下去。

解决方法

为了解决这个线程不可见性的问题，可以使用以下两种常见方法：

  1. 使用 volatile 关键字：将 fag 声明为 volatile，这样可以确保任何线程对 fag 的写入都会立即对其他线程可见。
  2. 使用同步机制：使用 synchronized 关键字来确保对 fag 的读取和写入操作是安全的。

在这里，我们选择使用 volatile 关键字来解决这个问题。

public class Main {
    public static volatile int fag = 0; // 使用volatile关键字
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (fag == 0) {
                // Busy wait: 这里循环等待fag变为1
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            fag = 1; // 将fag设置为1
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("主线程结束");
    }
}

结果

通过将 fag 声明为 volatile，确保了对该变量的写入会使得线程 t1 线程能看到 fag 的最新值。即使线程 t2 在将 fag 改为1后，其他线程（如 t1）也能及时看到这一变化，而不会出现不可见性的问题，从而避免了 t1 进入死循环的情况。

在程序运行结束后，您将看到"主线程结束"的输出，表明所有线程都能正常结束。使用 volatile 关键字有效地解决了线程间的可见性问题。

 死锁

在多线程编程中，死锁是一种非常严重的问题，它会导致程序无法继续执行。产生死锁的典型条件通常可以归纳为以下四个必要条件：

  1. 互斥条件：至少有一个资源必须被一个线程持有，并且在该资源被其他线程请求时，该线程不能被剥夺，即资源只能被一个线程使用。

  2. 保持并等待条件：一个线程至少持有一个资源，并且正在等待获取其他资源。在这个状态下，线程不会释放它已持有的资源。

  3. 不剥夺条件：一旦资源被分配给某个线程，其他线程不能强制剥夺该资源，只有线程在完成其任务后才能释放它所持有的资源。

  4. 循环等待条件：存在一个线程集合 {T1, T2, ..., Tn}，其中 T1 等待 T2 持有的资源，T2 等待 T3 持有的资源，以此类推，直至 Tn 等待 T1 持有的资源。形成一种循环等待的关系。

死锁案例

假设有两个线程，线程A和线程B，它们分别需要获取两个锁，锁1和锁2。以下是代码示例：

class Lock {
    private final String name;

    public Lock(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class DeadlockExample {
    private static final Lock lock1 = new Lock("Lock1");
    private static final Lock lock2 = new Lock("Lock2");

    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread A: Holding lock 1...");
                
                // Simulate some work
                try { Thread.sleep(100); } catch (InterruptedException e) {}

                System.out.println("Thread A: Waiting for lock 2...");
                synchronized (lock2) {
                    System.out.println("Thread A: Acquired lock 2!");
                }
            }
        });

        Thread threadB = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread B: Holding lock 2...");
                
                // Simulate some work
                try { Thread.sleep(100); } catch (InterruptedException e) {}

                System.out.println("Thread B: Waiting for lock 1...");
                synchronized (lock1) {
                    System.out.println("Thread B: Acquired lock 1!");
                }
            }
        });

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

分析

在上面的代码中，线程A首先持有锁1，然后尝试去获取锁2。同时，线程B首先持有锁2，之后尝试获取锁1。这样就形成了循环等待，导致两个线程相互阻塞，从而发生死锁。

解决方法

为了避免这种死锁情况，可以使用以下解决方案：

  1. 按照固定顺序获取锁： 我们可以定义一个顺序，确保所有线程都按照相同的顺序获取锁，从而避免循环等待。
public class DeadlockPrevention {
    private static final Lock lock1 = new Lock("Lock1");
    private static final Lock lock2 = new Lock("Lock2");

    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            Lock firstLock = lock1;
            Lock secondLock = lock2;
            acquireLocks(firstLock, secondLock);
        });

        Thread threadB = new Thread(() -> {
            Lock firstLock = lock1;
            Lock secondLock = lock2;
            acquireLocks(firstLock, secondLock);
        });

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

    private static void acquireLocks(Lock firstLock, Lock secondLock) {
        synchronized (firstLock) {
            System.out.println(Thread.currentThread().getName() + ": Holding " + firstLock.getName() + "...");

            // Simulate some work
            try { Thread.sleep(100); } catch (InterruptedException e) {}

            synchronized (secondLock) {
                System.out.println(Thread.currentThread().getName() + ": Acquired " + secondLock.getName() + "!");
            }
        }
    }
}

在这个示例中，无论线程A还是线程B，都会按照同样的顺序（首先获取lock1，然后是lock2）来请求锁，由此避免了死锁情况的发生。

通过这些方法，可以有效减少多线程程序中的死锁风险，保证程序的稳定性。

为了有效避免死锁，可以考虑以下策略：

  • 资源有序分配：为所有资源定义一个全局的获取顺序，线程在请求资源时，按照这个顺序获取，从而避免循环等待的情况。

  • 使用超时机制：在尝试获取锁时，可以设定一个超时时间，若超时则放弃锁的请求，减少潜在的死锁情况。

  • 避免保持并等待：可以在开始线程时一次性请求所有所需资源，成功则继续执行，失败则释放所有已获得的资源。

  • 检测与恢复：定期检查系统中是否存在死锁，如果发现可以中断某些线程或者释放某些资源来解除死锁。

通过合理的设计与计划，可以有效减少死锁的可能性，提高系统的稳定性和可靠性。

一只淡水鱼66
关注
专栏目录
多线程 - 线程安全问题的产生 与 解决 - javaee
m0_69119792的博客
03-22 527
本篇通过了解线程不安全产生的原因，解决线程不安全的方式，一般出现线程不安全的情况的问题，如有错误，请在评论区指正，让我们一起交流，共同进步
单例模式中的线程安全问题
热门推荐
X_H学Java的博客
04-04 1万+
单例模式是面试中设计模式里考的最多的一个，本文就单例模式中的饿汉模式和懒汉模式中的线程安全进行说明，以及分别使用synchronized和双重校验锁使懒汉模式在多线程环境下为线程安全的
《JavaEE》线程安全问题的产生以及解决方案
1
03-26 432
使用synchronized关键字 被synchronized包裹起来的代码 即可保证操作的原子性使用volatile关键字 volatile和原子无关 但是能够保证内存可见性 禁止了编译器进行优化在适当的时机 添加synchronized 配合volatile可以在一定程序上保证我们的线程安全t=N2N8《JavaEE》锁的多种形态http://t.csdn.cn/hgMoT。
什么是线程安全？产生线程不安全的原因和处理方式
想听风雨的博客
12-01 1278
介绍了线程安全问题的概念。 介绍了出现线程不安全的原因，以及其处理方式。 这是多线程编程的重点。
【后端开发】JavaEE初阶—线程安全问题与加锁原理（超详解）
GGBond778的博客
09-24 1371
本期总结了关于多线程编程的重要问题，线程状态，以及线程安全问题讲解，并且如何解决线程安全问题，进行了原理讲解，并提出加锁的概念和实现；还附上了代码加以讲解
笔记14-JAVAEE之多线程初阶
12-16
【JavaEE之多线程初阶】 在JavaEE开发中，多线程是提升系统性能和并发处理能力的重要手段。...在实际开发中，还要注意线程安全问题，正确使用同步机制，以及根据需求选择合适的线程管理策略，如线程池。
JavaEE基础教程 多线程PPT教案学习.pptx
09-30
但是，多线程编程也存在一些挑战，如线程安全、数据一致性等问题。 8. 多线程编程的应用：多线程编程广泛应用于各种领域，如Web 服务器、数据库服务器、操作系统等。多线程编程可以提高服务器的处理能力，提高系统...
【Java多线程进阶】CAS机制
我的主页
05-31 3219
本期讲解：CAS机制的原理，Java标准库中的原子类使用CAS机制，自旋锁使用CAS机制，CAS出现的ABA问题以及解决方案。
JavaEE学习[JavaSE-06多线程.rar]
03-29
1. **线程安全**：当多个线程访问同一对象时，如果始终保持正确性，即不出现数据不一致的情况，那么这个对象就是线程安全的。 2. **同步机制**：为了防止多个线程同时操作共享资源导致的数据混乱，Java提供了同步...
每天40min，我们一起用70天稳扎稳打学完《JavaEE初阶》——4/70 第四天【多线程安全问题原因】【如何解决线程安全问题】【指令重排序问题（可以用单例模式的懒汉模式举例）】
蓝天it（让亿万孩子在蓝天下共享优质教育）
08-03 63
专注 效率 记忆预习 笔记 复习 做题欢迎观看我的博客，如有问题交流，欢迎评论区留言，一定尽快回复！（大家可以去看我的专栏，是所有文章的目录）文章字体风格：红色文字表示：重难点★✔蓝色文字表示：思路以及想法★✔转发！本系列通过70天学习完JavaEE初阶，我们不图快，只求稳扎稳打。由于我高三是在家自学的，经验告诉我，学习一定要长期积累，并且及时复习，由于现在课程知识在网络上非常多，大家不知道学习进度以及方向，会感到迷茫，为了稳扎稳打，稳定学习，所以我推出此系列。
【JavaEE】——多线程常用类
2301_80133875的博客
09-30 990
Callable的call方法，FutureTask类，ReentrantLock可重入锁和对比，Semaphore信号量（PV操作）CountDownLatch锁存器，
基于J2EE技术的高校社团综合服务系统
abo2022的博客
09-30 540
jdk版本:jdk1.8+编程语言: java框架支持：springboot/ssm/springcloud分布式微服务数据库: mysql 版本不限数据库工具：Navicat/SQLyog都可以前端：vue.js+ElementUI开发工具：IDEA 或者eclipse都支持技术范围：SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等设计与开发。Java。
【JavaEE】——多重锁，死锁问题和解决思路
2301_80133875的博客
09-23 1285
加锁的“可重入性”，死锁，产生死锁的四个必要条件，避免死锁的解决思路
【JavaEE】——线程池大总结
2301_80133875的博客
09-27 1461
线程数量问题解决方式，代码实现线程池，ThreadPoolExecutor（核心构造方法），参数的解释（面试：拒绝策略），Executors，工厂模式，工厂类
计算机毕业设计党建学习网站查看发布党建评论留言搜索部署安装/springboot/javaWEB/J2EE/MYSQL数据库/vue前后分离小程序
计算机程序开发设计
09-27 1187
‌前端技术‌：采用Vue.js框架，结合Element-UI、HTML、CSS、JavaScript和JQuery等技术，实现用户界面的美观与交互性。Vue.js提供组件化的开发模式，便于维护和扩展。‌后端技术‌：使用Spring Boot框架，简化Spring应用的开发过程，提供自动配置、内嵌服务器等功能。Java作为编程语言，保证了系统的稳定性和安全性。‌数据库技术‌：采用Mysql数据库，存储用户信息、学习资源、学习记录等数据，支持高并发访问和大数据量存储。‌开发环境。
【JavaEE初阶】深入解析死锁的产生和避免以及内存不可见问题
GGBond778的博客
09-26 2426
本期总结了关于多线程的重要知识即死锁，分别从造成原因和如何进解决提出了关于小编的理解，以及线程安全问题之内存可见性问题，并附上了代码供小伙伴们参考参考~~~
鸿蒙开发（NEXT/API 12）【申请接入Wear Engine服务】 穿戴服务
最新发布
鸿蒙的技术博客
09-30 762
申请Wear Engine服务前（开发者需实名认证为个人开发者或者企业开发者，认证前，请先了解二者的[权益区别] ），确认开发环境并完成创建项目、创建HarmonyOS应用等基本准备工作，再继续进行以下开发活动。
评论 107
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值