Java多线程：常见同步问题实例分析

原创朱雀 2024-11-11 20:06 5阅读 0赞

Java多线程编程中，同步问题是一个常见的话题。同步问题通常涉及到多个线程访问共享资源时的竞态条件、死锁、活锁等问题。以下是一些常见的同步问题实例分析：

###1.竞态条件（Race Condition）

**问题描述**：
当多个线程访问同一个资源，并且至少有一个线程在修改这个资源时，如果对资源的访问没有适当的同步措施，就可能发生竞态条件。

**示例代码**：
```javaclass Counter {
 private int count =0;

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

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

###2.死锁（Deadlock）

**问题描述**：
当两个或多个线程在等待对方释放资源，而自己又持有对方需要的资源时，就会发生死锁。

**示例代码**：
```javapublic class DeadlockExample {
 private static final Object lock1 = new Object();
 private static final Object lock2 = new Object();

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

new Thread(() -> {
 synchronized (lock2) {
 try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 synchronized (lock1) {
 System.out.println("Thread2 acquired lock1");
 }
 }
 }).start();
 }
}
```
在这个例子中，两个线程分别尝试先获取 `lock1` 和 `lock2`，然后获取另一个锁，这会导致死锁。

###3.活锁（Livelock）

**问题描述**：
活锁是指两个或多个线程在尝试执行操作时，由于不断改变策略而无法取得进展的状态。

**示例代码**：
```javapublic class LivelockExample {
 public static void main(String[] args) {
Thread t1 = new Thread(() -> {
 while (true) {
if (someCondition()) {
 break;
 }
//改变策略 }
 });

Thread t2 = new Thread(() -> {
 while (true) {
if (someCondition()) {
 break;
 }
//改变策略 }
 });

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

private static boolean someCondition() {
//检查条件 return false;
 }
}
```
在这个例子中，两个线程都在检查一个条件，并根据条件改变策略，但可能永远无法满足条件，导致活锁。

###4.可见性问题（Visibility）

**问题描述**：
当一个线程修改了共享变量的值，而另一个线程没有看到这个新值时，就会发生可见性问题。

**示例代码**：
```javaclass VisibilityExample {
 private static boolean flag = false;

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
 flag = true;
 });

Thread t2 = new Thread(() -> {
 while (!flag) {
//循环检查flag }
 System.out.println("Flag is true");
 });

t1.start();
t2.start();
 }
}
```
在这个例子中，`t2`线程可能看不到 `t1`线程对 `flag` 的修改，导致它可能永远循环。

### 解决方法- **竞态条件**：使用 `synchronized` 关键字或 `ReentrantLock`等锁机制来确保原子性。
- **死锁**：避免嵌套锁，使用 `tryLock` 或设置超时。
- **活锁**：确保线程在等待一段时间后能够取得进展。
- **可见性问题**：使用 `volatile` 关键字或 `Atomic` 类来保证变量的可见性。

同步问题的处理需要根据具体情况选择合适的同步机制。