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

产生线程不安全的原因

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

共享可变状态：当多个线程对共享的可变数据进行读写时，如果没有适当的同步机制，可能导致数据的不一致性。例如，两个线程同时修改一个共享变量，最终的结果可能取决于线程的执行顺序。
缺乏同步：在没有使用synchronized关键字或其他同步机制（如Lock）进行保护的情况下，多个线程可以同时进入临界区，从而导致线程安全问题。
指令重排序：为了提高执行效率，Java虚拟机和处理器可能会对指令进行重排序，这种行为在多线程环境中可能导致不可预期的结果，尤其是在多个线程依赖某些变量的状态时。
原子性问题：某些操作在Java中并不是原子的，例如对对象属性的读-改-写操作。在多线程环境下，这类操作必须通过同步处理以确保原子性。
死锁：尽管死锁本身不直接导致线程不安全，但在复杂的同步情况下，死锁可能导致某些线程无法继续执行，从而影响整体程序的正确性与稳定性。
不可见性：当一个线程对共享变量的修改在其他线程中不可见时，可能导致一些线程读取到过时的值。这通常可以通过使用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。
将新值写回。

在多线程环境中，多个线程可能会同时对同一变量进行

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。

解决方法

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

使用synchronized关键字：将increment方法同步，以确保同一时刻只有一个线程能执行该操作。
****使用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

线程陷入死循环，程序执行不会继续下去。

解决方法

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

使用 volatile 关键字：将 fag 声明为 volatile，这样可以确保任何线程对 fag 的写入都会立即对其他线程可见。
使用同步机制：使用 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

关键字有效地解决了线程间的可见性问题。

死锁

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

互斥条件：至少有一个资源必须被一个线程持有，并且在该资源被其他线程请求时，该线程不能被剥夺，即资源只能被一个线程使用。
保持并等待条件：一个线程至少持有一个资源，并且正在等待获取其他资源。在这个状态下，线程不会释放它已持有的资源。
不剥夺条件：一旦资源被分配给某个线程，其他线程不能强制剥夺该资源，只有线程在完成其任务后才能释放它所持有的资源。
循环等待条件：存在一个线程集合 {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。这样就形成了循环等待，导致两个线程相互阻塞，从而发生死锁。

解决方法

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

按照固定顺序获取锁：我们可以定义一个顺序，确保所有线程都按照相同的顺序获取锁，从而避免循环等待。

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

）来请求锁，由此避免了死锁情况的发生。

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

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

资源有序分配：为所有资源定义一个全局的获取顺序，线程在请求资源时，按照这个顺序获取，从而避免循环等待的情况。
使用超时机制：在尝试获取锁时，可以设定一个超时时间，若超时则放弃锁的请求，减少潜在的死锁情况。
避免保持并等待：可以在开始线程时一次性请求所有所需资源，成功则继续执行，失败则释放所有已获得的资源。
检测与恢复：定期检查系统中是否存在死锁，如果发现可以中断某些线程或者释放某些资源来解除死锁。

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

标签： java-ee 线程安全操作系统

本文转载自: https://blog.csdn.net/yican2580/article/details/141463585
版权归原作者 一只淡水鱼66 所有，如有侵权，请联系我们删除。

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

产生线程不安全的原因

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

共享可变状态案例

解决方法

指令重排序案例

解决方法

不可见性案例

解决方法

死锁

死锁案例

解决方法

发表评论

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

关于作者

overfit同步小助手

相关阅读

文章导航