Java多线程同步代码的常见问题和解决方案

原创我就是我 2024-12-11 23:18 129阅读 0赞

在Java多线程编程中，常见的同步问题及解决方案包括：

1. **死锁**：多个线程相互等待对方释放资源。解决方案是使用`synchronized`关键字或`ReentrantLock`来控制锁定范围。

```java
// 使用 synchronized 关键字
class DeadlockExample {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

public void methodA() {
        synchronized (lock1) { // 锁住对象 lock1
            synchronized (lock2) { // 同时锁住对象 lock1 和 lock2
                // 这里执行耗时操作
            }
        }
    }

public void methodB() {
        synchronized (lock2) { // 锁住对象 lock2
            synchronized (lock1) { // 同时锁住对象 lock1 和 lock2
                // 这里执行耗时操作
            }
        }
    }
}

// 使用 ReentrantLock 实例同步
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class DeadlockExampleReentrant {
    private Lock lock1 = new ReentrantLock();
    private Lock lock2 = new ReentrantLock();

public void methodA() {
        lock1.lock(); // 获取锁1
        try {
            lock2.lock(); // 获取锁2
            try {
                // 这里执行耗时操作
            } finally {
                lock2.unlock(); // 释放锁2
            }
        } finally {
            lock1.unlock(); // 释放锁1
        }
    }

public void methodB() {
        lock2.lock(); // 获取锁2
        try {
            lock1.lock(); // 获取锁1
            try {
                // 这里执行耗时操作
            } finally {
                lock1.unlock(); // 释放锁1
            }
        } finally {
            lock2.unlock(); // 释放锁2
        }
    }
}
```

通过这两种方式，可以有效地避免和解决Java多线程中的死锁问题。