并发控制：Java多线程同步问题案例

原创深碍√TFBOYSˉ_ 2024-11-01 04:51 14阅读 0赞

在Java中，多线程同步是一个重要的概念，它确保了多个线程在访问共享资源时的一致性和线程安全。以下是一些常见的Java多线程同步问题案例，以及它们的解决方案。

###1.共享资源竞争（Race Condition）

**问题描述**：
当多个线程同时访问和修改同一个资源时，可能会出现竞争条件，导致数据不一致。

**案例**：
```javapublic class Counter {
 private int count =0;

public void increment() {
 count++; //非原子操作 }

public int getCount() {
 return count;
 }
}
```
在这个例子中，`increment()` 方法不是原子的，因为它涉及到读取、增加和写入三个步骤。如果多个线程同时调用这个方法，可能会导致`count`的值不正确。

**解决方案**：
使用`synchronized`关键字来同步方法或代码块。
```javapublic synchronized void increment() {
 count++;
}
```
或者使用`ReentrantLock`。
```javaimport java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
 private final Lock lock = new ReentrantLock();
 private int count =0;

public void increment() {
lock.lock();
 try {
 count++;
} finally {
lock.unlock();
 }
 }

public int getCount() {
 return count;
 }
}
```###2.死锁（Deadlock）

**问题描述**：
当两个或多个线程在等待对方释放资源时，它们会陷入死锁状态，导致程序无法继续执行。

**案例**：
```javapublic class DeadlockExample {
 private final Object lock1 = new Object();
 private final Object lock2 = new Object();

public void method1() {
 synchronized (lock1) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock2) {
 System.out.println("Lock2 acquired");
 }
 }
 }

public void method2() {
 synchronized (lock2) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Lock1 acquired");
 }
 }
 }
}
```
在这个例子中，`method1` 和 `method2`可能会同时尝试获取`lock1`和`lock2`，导致死锁。

**解决方案**：
确保所有线程以相同的顺序获取锁，或者使用`tryLock`尝试获取锁，并设置超时。
```javapublic void method1() {
 synchronized (lock1) {
 try {
if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) {
 try {
 System.out.println("Lock2 acquired");
} finally {
lock2.unlock();
 }
 }
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
}
```###3.可见性问题（Visibility）

**问题描述**：
当一个线程修改了共享变量的值，而另一个线程可能看不到这个变化，因为变量的值可能被缓存在寄存器或线程栈中。

**案例**：
```javapublic class VisibilityExample {
 private static boolean flag = false;

public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
 while (!flag) {
//循环检查flag }
 System.out.println("Flag is true");
 });
t.start();

Thread.sleep(1000); //模拟其他操作 flag = true; // 修改flag }
}
```
在这个例子中，即使`flag`被设置为`true`，子线程可能仍然看不到这个变化。

**解决方案**：
使用`volatile`关键字来确保变量的可见性。
```javaprivate static volatile boolean flag = false;
```这些案例展示了多线程同步中的一些常见问题及其解决方案。在实际开发中，合理使用同步机制是非常重要的，以确保程序的正确性和性能。