Java并发编程：Lock接口及死锁问题实例

原创深碍√TFBOYSˉ_ 2024-09-10 08:03 61阅读 0赞

在Java的并发编程中，`Lock`接口是线程安全的关键。`Lock`提供了可重入、公平性等特性。

以下是一些关于`Lock`接口的基本概念和实例：

1. **内置锁：**Java的`Synchronized`关键字实际上就是创建了一个`ReentrantLock`对象。例如：
```java
public class SynchronizedExample {
    private Object lock = new Object();

public synchronized void method() {
        // Some critical code here
        System.out.println("Method executed in locked state.");
    }

public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();
        Thread thread1 = new Thread(() -> {
            example.method(); // This will be blocked until lock is released.
        }));
        Thread thread2 = new Thread(() -> {
            example.method(); // Same blocking behavior
        }));

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

// Wait for threads to finish their execution
        thread1.join();
        thread2.join();

System.out.println("Example completed.");
    }
}
```
2. **死锁：**当两个或更多的线程在执行过程中，因争夺资源而造成的一种互相等待的现象称为死锁。

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

public void method1() {
        synchronized (lock1) {
            System.out.println("Thread 1 entered lock 1.");
            // Do some critical work here

System.out.println("Thread 1 released lock 1 and entered lock 2.");
            synchronized (lock2) {
                System.out.println("Thread 1 finally entered lock 2.");
                // Some final operations
            }
        }
    }

public void method2() {
        synchronized (lock2) {
            System.out.println("Thread 2 entered lock 2.");
            // Do some critical work here

System.out.println("Thread 2 released lock 2 and entered lock 1.");
            synchronized (lock1) {
                System.out.println("Thread 2 finally entered lock 1.");
                // Some final operations
            }
        }
    }

public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();
        Thread thread1 = new Thread(() -> {
            example.method1(); // Method1 acquires lock2 and releases it before acquiring lock1.
        }));
        Thread thread2 = new Thread(() -> {
            example.method2(); // Method2 tries to acquire lock1 while thread1 still holds lock2.
        }));

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

// Wait for threads to finish their execution
        thread1.join();
        thread2.join();

System.out.println("Example completed.");
    }
}
```
在这个例子中，如果两个线程按照`method1 -> method2`的顺序执行，就很容易引发死锁。