当前位置：首页 > news >正文

Java学习手册：常见并发问题及解决方案

news 2025/5/2 8:40:55

在这里插入图片描述

在Java并发编程中，开发者常常会遇到各种并发问题，这些问题可能导致程序行为不可预测、性能下降甚至程序崩溃。以下是一些常见的并发问题及其解决方案：

1.竞态条件（Race Condition）

竞态条件是指多个线程同时访问共享资源时，程序的行为依赖于线程的执行顺序，导致不可预测的结果。

问题示例

public class Counter {private int count = 0;public void increment() {count++;}public int getCount() {return count;}
}// 在多线程环境下，count++操作可能不原子，导致结果不准确

解决方案

使用synchronized关键字：确保同一时间只有一个线程可以执行increment方法。
使用原子类：AtomicInteger提供了原子的递增操作。

import java.util.concurrent.atomic.AtomicInteger;public class AtomicCounter {private AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet();}public int getCount() {return count.get();}
}

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();}
}

解决方案

按顺序获取锁：所有线程应以相同的顺序获取多个锁。
使用tryLock()方法：在尝试获取锁时设置超时时间，避免无限期等待。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class DeadlockSolution {private final Lock lock1 = new ReentrantLock();private final Lock lock2 = new ReentrantLock();public void method1() {lock1.lock();try {System.out.println("Thread 1: Holding lock 1...");lock2.lock();try {System.out.println("Thread 1: Holding lock 2...");} finally {lock2.unlock();}} finally {lock1.unlock();}}public void method2() {lock1.lock();try {System.out.println("Thread 2: Holding lock 1...");lock2.lock();try {System.out.println("Thread 2: Holding lock 2...");} finally {lock2.unlock();}} finally {lock1.unlock();}}
}

3.饥饿（Starvation）

饥饿是指某些线程长期无法获得资源，导致无法执行。

解决方案

使用公平锁：确保线程按请求顺序获得锁。
合理设置线程池参数：避免高优先级线程长期占用资源。

import java.util.concurrent.locks.ReentrantLock;public class FairLockExample {private final ReentrantLock lock = new ReentrantLock(true); // 公平锁public void accessResource() {lock.lock();try {// 访问资源} finally {lock.unlock();}}
}

4.活锁（Livelock）

活锁是指线程不断尝试执行但无法取得进展，通常因为线程反复“让步”。

解决方案

引入随机等待时间：避免线程反复冲突。

public class LivelockSolution {public void avoidLivelock() {while (true) {try {// 尝试执行任务break;} catch (ConflictException e) {// 随机等待try {Thread.sleep((long) (Math.random() * 1000));} catch (InterruptedException ie) {Thread.currentThread().interrupt();}}}}
}

5.资源泄漏（Resource Leak）

资源泄漏是指线程未正确释放资源，导致资源耗尽。

解决方案

使用try-with-resources：确保资源自动关闭。
在finally块中释放资源：确保资源在异常情况下也能被释放。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class ResourceLeakSolution {public void readResource() {try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {String line;while ((line = reader.readLine()) != null) {System.out.println(line);}} catch (IOException e) {e.printStackTrace();}}
}