Java并发编程中的锁与死锁实例

原创 - 日理万妓 2024-10-25 03:09 12阅读 0赞

在Java并发编程中，锁是一种同步机制，用于控制对共享资源的访问。死锁则是多个线程互相等待对方释放资源导致的一种僵局。

下面是一个简单的锁与死锁实例：

```java
// 创建两个互斥的资源
class Resource {
    private boolean locked;

public Resource() {
        locked = false;
    }

public synchronized void lock() {
        if (locked) {
            throw new IllegalStateException("Resource is already locked.");
        }
        locked = true;
    }

public synchronized void unlock() {
        if (!locked) {
            throw new IllegalStateException("Resource is not locked.");
        }
        locked = false;
    }
}

// 创建两个线程，分别尝试获取和释放资源
class ThreadA extends Thread {
    private Resource resource;

public ThreadA(Resource resource) {
        this.resource = resource;
    }

public void run() {
        try {
            // 线程试图获取资源
            resource.lock();
            System.out.println("Thread A has acquired the lock.");
            // 线程执行任务并释放资源
            doSomeWork();
            resource.unlock();
            System.out.println("Thread A has released the lock.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

private void doSomeWork() {
        try {
            Thread.sleep(2000); // 模拟耗时操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread {
    private Resource resource;

public ThreadB(Resource resource) {
        this.resource = resource;
    }

public void run() {
        try {
            // 线程试图释放资源，如果资源已被其他线程锁定，则会抛出异常
            resource.unlock();
            System.out.println("Thread B tried to unlock the lock but it was already locked.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 创建资源并启动两个线程
Resource resource = new Resource();
ThreadA threadA = new ThreadA(resource);
ThreadB threadB = new ThreadB(resource);

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

// 等待所有线程执行完毕
while (true) {
    if (!threadA.isAlive() && !threadB.isAlive()) {
        break;
    }
}
```

在这个例子中，`Resource`类代表两个互斥的资源。`ThreadA`和`ThreadB`分别代表两个线程，它们试图获取资源并释放资源。

如果线程A在获取锁后执行耗时操作，而线程B尝试在锁已被其他线程锁定的情况下释放锁，就会发生死锁。