java 什么情况会有多个线程安全问题

powerTan01

已于 2023-05-11 10:29:27 修改

阅读量122

点赞数

文章标签： java jvm 开发语言

于 2023-05-11 10:28:00 首次发布

本文链接：https://blog.csdn.net/tanwu1/article/details/130616303

版权

在Java中，多线程安全问题通常是由于多个线程同时访问和修改共享的变量所引起的。以下是一些可能会导致多个线程安全问题的情况，并提供了相应的示例代码。

竞态条件（Race Condition）

竞态条件指的是多个线程同时访问和修改共享的变量，从而导致结果依赖于执行时序的问题。以下是一个示例代码，演示了竞态条件的问题：

public class RaceConditionDemo {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                count++; // 对共享变量进行自增操作
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

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

        System.out.println("count: " + count); // 输出结果不一定为 2000
    }
}

在这个示例中，我们创建了两个线程，并对共享变量count进行1000次自增操作。由于两个线程可能会同时修改count变量，因此在输出count变量时，结果可能不是期望的2000。

死锁（Deadlock）

死锁指的是多个线程在竞争资源时互相等待，从而导致程序无法继续执行的情况。以下是一个示例代码，演示了死锁的问题：

public class DeadlockDemo {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread1 acquired lock1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread1 acquired lock2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread2 acquired lock2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread2 acquired lock1");
                }
            }
        });

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

在这个示例中，我们创建了两个线程，每个线程都会先获取一个锁，然后尝试获取另一个锁。由于两个线程都需要获取对方已经持有的锁，因此可能会出现死锁的情况，程序无法继续执行。

未加锁的共享变量访问

未加锁的共享变量访问可能会导致数据竞争的问题，从而导致程序出现不可预料的错误
以下是一个未加锁的共享变量访问的示例代码：

public class UnsyncAccessDemo {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                count++; // 对共享变量进行自增操作
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

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

        System.out.println("count: " + count); // 输出结果不一定为 2000
    }
}

在这个示例中，我们依然是对共享变量count进行1000次自增操作，但是没有对访问count变量进行同步。由于两个线程可能会同时访问和修改count变量，因此在输出count变量时，结果可能不是期望的2000。

总的来说，以上示例展示了一些可能会引起多线程安全问题的情况。在编写多线程程序时，需要特别注意对共享变量的访问和修改，避免出现竞态条件、死锁、未加锁的共享变量访问等问题。为了保证线程安全，可以使用synchronized关键字、Lock接口、Atomic类等机制来对共享变量进行同步和原子操作。