Java多线程并发问题：锁和死锁示例

原创电玩女神 2024-12-01 02:09 60阅读 0赞

在Java多线程编程中，锁是一种同步机制，用于控制对共享资源的访问。如果管理不当，可能会导致死锁。

**1. 锁的理解**

- `synchronized`关键字：这是Java中最常用的锁，用于修饰方法或代码块。

- 示例：
```java
public class Counter {
    private int count;

public synchronized void increment() {
        count++;
    }

public synchronized int value() {
        return count;
    }
}
```

- 访问控制：锁定一个资源后，后续线程需要获得相同锁才能访问该资源。

**2. 死锁示例**

- 两个线程互相等待对方释放的锁，从而导致无法继续执行。

- 示例：
```java
public class DeadlockExample {
    private Object lock1 = new Object();
    private Object lock2 = new Object();

// 线程A和B分别对锁1和锁2进行操作
    public void threadA() throws InterruptedException {
        synchronized (lock1) {
            System.out.println("Thread A acquires lock 1");

// 等待锁2被释放
            synchronized (lock2) {
                System.out.println("Thread A waits for lock 2");

// 死锁，线程A无法继续执行
            }
        }
    }

public void threadB() throws InterruptedException {
        synchronized (lock2) {
            System.out.println("Thread B acquires lock 2");

// 等待锁1被释放
            synchronized (lock1) {
                System.out.println("Thread B waits for lock 1");

// 死锁，线程B无法继续执行
            }
        }
    }

public static void main(String[] args) throws InterruptedException {
        DeadlockExample example = new DeadlockExample();
        Thread threadA = new Thread(example::threadA));
        Thread threadB = new Thread(example::threadB));

threadA.start();
        threadB.start();

// 等待所有线程执行完毕
        threadA.join();
        threadB.join();

System.out.println("Execution completed");
    }
}
```

这个例子中，线程A先获取锁1，然后等待锁2被释放。同时，线程B的逻辑与之相反。

由于锁是相互独立的，所以在没有其他线程尝试同时获取锁1和锁2的情况下，这种情况下会形成死锁。