Java多线程编程：同步锁和死锁案例

原创迷南。 2024-09-17 14:57 90阅读 0赞

Java多线程编程中，同步锁主要有两种方式：synchronized关键字和Lock接口。

1. `synchronized`关键字：

```java
// 假设有一个共享资源类Resource
class Resource {
    private int count;

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

// 其他方法...
}

public class SynchronizedExample {
    public static void main(String[] args) {
        Resource resource = new Resource();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                resource.increment(); // 注意这里的synchronized
            }
        }));

Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                resource.increment(); // 注意这里的synchronized
            }
        }));

thread1.start();
        thread2.start();

// 这里可能会出现死锁，因为两个线程都在试图增加资源的计数
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

2. `Lock`接口：

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Resource {
    private Lock lock; // 使用ReentrantLock

public Resource() {
        this.lock = new ReentrantLock(); // 初始化锁
    }

// 同步方法...
}

public class LockExample {
    public static void main(String[] args) {
        Resource resource = new Resource();

Thread thread1 = new Thread(() -> {
            try {
                resource.lock(); // 获取锁
                for (int i = 0; i < 5; i++) {
                    resource.increment(); // 同步方法
                }
                resource.unlock(); // 释放锁
            } catch (InterruptedException | LockUnlockedException e) {
                e.printStackTrace();
            }
        }));

Thread thread2 = new Thread(() -> {
            try {
                resource.lock(); // 获取锁
                for (int i = 0; i < 10; i++) {
                    resource.increment(); // 同步方法
                }
                resource.unlock(); // 释放锁
            } catch (InterruptedException | LockUnlockedException e) {
                e.printStackTrace();
            }
        }));

thread1.start();
        thread2.start();

try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

以上代码展示了如何使用`synchronized`关键字和`Lock`接口来同步多个线程对共享资源的访问。在处理多线程并发时，理解并正确应用这些机制是非常重要的。