Java中的同步锁：死锁和活锁问题实例

原创向右看齐 2024-11-06 18:07 12阅读 0赞

在Java中，同步锁是用于控制多个线程对共享资源访问的一种机制，以确保在任何时刻只有一个线程可以访问特定的资源。然而，不当的使用同步锁可能会导致死锁和活锁问题。

###死锁（Deadlock）

死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种僵局，导致这些线程无法继续执行。在Java中，死锁通常发生在多个线程尝试以不同的顺序获取多个锁时。

**死锁示例：**

```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");
 }
 }
 }

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();
 }
}
```在这个例子中，`method1`和`method2`分别尝试以不同的顺序获取`lock1`和`lock2`。如果`method1`先获取了`lock1`，而`method2`先获取了`lock2`，那么两个线程都会等待对方释放锁，导致死锁。

###活锁（Livelock）

活锁是指两个或多个线程在执行过程中，由于不断尝试获取资源而未能成功，导致这些线程不断循环尝试，但始终无法继续执行。活锁与死锁不同，线程不会阻塞，但也无法取得进展。

**活锁示例：**

```javapublic class LivelockExample {
 public void method1() {
 while (true) {
 synchronized (this) {
if (Thread.currentThread().getName().equals("Thread-1")) {
 System.out.println("Thread-1 is running");
 break;
 }
 }
 }
 }

public void method2() {
 while (true) {
 synchronized (this) {
if (Thread.currentThread().getName().equals("Thread-2")) {
 System.out.println("Thread-2 is running");
 break;
 }
 }
 }
 }

public static void main(String[] args) {
 LivelockExample example = new LivelockExample();
Thread t1 = new Thread(example::method1, "Thread-1");
Thread t2 = new Thread(example::method2, "Thread-2");
t1.start();
t2.start();
 }
}
```在这个例子中，`method1`和`method2`都尝试获取同一个锁，但根据当前线程的名字来决定是否继续执行。如果`Thread-1`和`Thread-2`几乎同时运行，它们会不断尝试获取锁并释放，但始终无法进入临界区，导致活锁。

###解决方案- **死锁解决方案**：避免以不同的顺序获取锁，使用`Lock`接口和`tryLock`方法来尝试获取锁，并设置超时。
- **活锁解决方案**：引入随机退避策略，即在尝试获取锁失败后，线程随机等待一段时间再重试。

正确使用同步锁和并发控制机制是避免这些问题的关键。