Java中常见的并发问题与解决方案

项目笔记与工具库

于 2024-09-15 16:44:06 发布

阅读量1.1k

点赞数 22

文章标签： python java 开发语言

本文链接：https://blog.csdn.net/qq_40697623/article/details/142285900

版权

Java中常见的并发问题与解决方案

内容概述

多线程编程是Java中构建高性能应用程序的重要部分。然而，并发带来了诸多问题，尤其在多个线程访问共享资源时，容易引发如死锁、竞态条件等问题。这些问题如果处理不当，会导致程序行为不可预测，甚至崩溃。本文将分析Java中常见的并发问题，并介绍相应的解决策略和工具，以帮助你提高多线程程序的健壮性。

学习目标

本文将帮助你：

了解并发编程中的常见问题及其原因。
掌握解决这些问题的常用策略与工具。
提高多线程程序的稳定性与性能。

1. 竞态条件（Race Condition）

问题描述

竞态条件发生在多个线程同时访问和修改共享资源时，程序的结果取决于线程的执行顺序。线程如果没有得到适当的同步控制，可能会导致数据不一致或非预期的结果。

示例

public class RaceConditionExample {
    private int counter = 0;

    public void increment() {
        counter++;
    }

    public static void main(String[] args) throws InterruptedException {
        RaceConditionExample example = new RaceConditionExample();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

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

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

        System.out.println("Counter value: " + example.counter);
    }
}

在上面的代码中，由于多个线程同时访问counter，线程安全没有得到保障，导致counter的最终值不正确。

解决方案

使用同步方法：确保同一时间只有一个线程访问共享资源。
```
public synchronized void increment() {
    counter++;
}
```
使用原子类：例如AtomicInteger，它提供了原子操作，避免了手动同步。
```
private AtomicInteger counter = new AtomicInteger(0);
```

2. 死锁（Deadlock）

问题描述

死锁发生在两个或多个线程互相等待对方释放资源时，造成所有线程都无法继续执行。死锁通常发生在多个线程需要同时获取多个资源时。

示例

public class DeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            System.out.println("Thread 1: Holding lock 1...");
            synchronized (lock2) {
                System.out.println("Thread 1: Holding lock 2...");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Thread 2: Holding lock 2...");
            synchronized (lock1) {
                System.out.println("Thread 2: Holding lock 1...");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        Thread t1 = new Thread(example::method1);
        Thread t2 = new Thread(example::method2);

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

自持有一个锁，并等待另一个锁的释放，从而造成死锁。

解决方案

资源获取顺序一致：确保所有线程以相同的顺序获取多个锁，避免死锁。

public void method1() {
    synchronized (lock1) {
        synchronized (lock2) {
            // critical section
        }
    }
}

public void method2() {
    synchronized (lock1) {  // 改变锁的顺序
        synchronized (lock2) {
            // critical section
        }
    }
}

使用 tryLock()：使用显式锁（如ReentrantLock）的tryLock()方法，如果无法立即获得锁，可以选择超时或放弃，从而避免死锁。

3. 资源饥饿（Starvation）

问题描述

资源饥饿发生在某个线程长期无法获取所需资源，导致无法执行。这通常是由于高优先级线程频繁占用资源，低优先级线程无法及时获取资源。

解决方案

公平锁：使用公平锁（如ReentrantLock），确保资源的公平分配。
```
ReentrantLock fairLock = new ReentrantLock(true);
```
线程池：合理使用线程池可以帮助管理线程的优先级和执行顺序，避免某些线程被长时间饿死。

4. 活锁（Livelock）

问题描述

活锁与死锁不同，线程不会被阻塞，但由于不断地“让步”或重试操作，导致程序无法继续。线程之间不断重复执行某种动作而不前进。

解决方案

设置重试次数：为重试操作设定上限，避免线程无限循环。

引入随机等待：通过引入随机等待时间，避免线程的重复让步。

public void tryAction() {
    int attempt = 0;
    while (attempt < MAX_ATTEMPTS) {
        if (tryToAct()) {
            break;
        }
        attempt++;
        Thread.sleep(new Random().nextInt(100));
    }
}