并发问题难解：Java线程安全问题实例

原创布满荆棘的人生 2024-11-09 19:42 32阅读 0赞

在Java中，线程安全问题通常涉及到多个线程同时访问和修改共享资源时可能出现的问题。以下是一些常见的线程安全问题实例，以及它们可能产生的后果和解决方案。

###1.共享变量的竞态条件（Race Condition）

**问题实例：**
假设有两个线程同时对一个共享变量进行增加操作。

```javapublic class Counter {
 private int count =0;

public void increment() {
 count++; //非原子操作 }
}
```**后果：**
由于`count++`不是原子操作，它包含三个步骤：读取`count`的值，增加1，写回内存。如果两个线程同时执行`increment()`方法，它们可能会读取相同的`count`值，然后各自增加1，最后写回内存，导致实际增加的次数少于预期。

**解决方案：**
使用`synchronized`关键字或`AtomicInteger`来确保操作的原子性。

```javapublic class Counter {
 private int count =0;

public synchronized void increment() {
 count++;
 }
}
// 或者import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
 private AtomicInteger count = new AtomicInteger(0);

public void increment() {
 count.incrementAndGet();
 }
}
```###2.可见性问题（Visibility）

**问题实例：**
一个线程修改了共享变量的值，但另一个线程可能看不到这个变化。

```javapublic class VisibilityExample {
 private static boolean flag = false;

public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
 flag = true;
 System.out.println("Flag is set to true");
 });
t.start();
t.join();

System.out.println("Main thread sees flag: " + flag);
 }
}
```**后果：**
如果`flag`的修改对主线程不可见，主线程可能会看到`flag`的旧值。

**解决方案：**
使用`volatile`关键字确保变量的修改对所有线程立即可见。

```javapublic class VisibilityExample {
 private static volatile boolean flag = false;

public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
 flag = true;
 System.out.println("Flag is set to true");
 });
t.start();
t.join();

System.out.println("Main thread sees flag: " + flag);
 }
}
```###3.死锁（Deadlock）

**问题实例：**
两个线程各自持有一个资源，同时尝试获取对方持有的资源。

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

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

public void method2() {
 synchronized (lock2) {
 try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Lock1 acquired");
 }
 }
 }
}
```**后果：**
两个线程都在等待对方释放锁，导致死锁。

**解决方案：**
确保所有线程以相同的顺序获取锁，或者使用`tryLock()`尝试获取锁，并设置超时。

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

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

public void method2() {
 synchronized (lock2) {
 try {
if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) {
 try {
 System.out.println("Lock1 acquired");
} finally {
lock1.unlock();
 }
 }
} catch (InterruptedException e) {
e.printStackTrace();
 }
 }
 }
}
```这些是一些基本的线程安全问题和解决方案。在实际应用中，可能需要根据具体情况选择合适的同步机制。