显示带有信号量的死锁的简单示例

Question

我目前正在使用操作系统，我们的老师为我们的实验室分配了此问题，但他的帮助不是很大。因此，我需要显示带有信号量的死锁的基本示例，并且我的输出需要演示死锁的发生。我假设他的意思是如果发现我的例外情况。这和我已经接近了。

import java.util.concurrent.Semaphore;
public class deadlockTest2
{
    private Semaphore sem1=new Semaphore(1);
    private Semaphore sem2=new Semaphore(1);
    private int num;

    public deadlockTest2(int random)
    {
            num=random;
    }
    public void run()
    {
        try 
        {
            sem1.acquire();
        }
         catch (InterruptedException e)
        {
            System.out.println("I am deadlocked");}
        }

    public static void main(String[] args)
    {
        deadlockTest2 tester=new deadlockTest2(5);
        deadlockTest2 tester2=new deadlockTest2(20);
        tester.run();
        tester2.run();
    }   
}

〜
〜
上午我还差得远？我一直在阅读材料，但没有完全掌握。我想我不明白什么是过程。有人请帮忙。

Answer 1

当两个或多个进程互相阻止对方完成执行时，就会发生死锁。您可以将进程视为一个单独的程序；它们与您的其他进程同时运行。

死锁的一个基本示例是具有两个进程和两个互斥体的程序，其中每个进程都需要访问两个互斥体，但在获取另一个互斥体之前不会释放自己的互斥体。一个例子：

1. 进程A锁定互斥锁A
2. 进程 B 锁定互斥体 B
3. 进程A想要锁定互斥体B，但已经被进程B锁定了！
4. 进程B想要锁定互斥锁A，但已经被进程A锁定了！

注意：互斥锁只是一个值为 1 的信号量。

很容易看出这种情况将永远持续下去，因为两个进程都不会在锁定另一个资源之前释放自己的资源。这两个进程陷入僵局。

我在实现中看到的第一个问题是，您为每个进程提供了一组自己的信号量，这是行不通的，因为您需要在进程之间共享这些信号量。就好像你这样做了：

1. 进程A锁定互斥量A_A（存在于进程A中）
2. 进程B锁定互斥体B_B（存在于进程B中）
3. 进程A锁定互斥体B_A（存在于进程A中）
4. 进程B锁定互斥量A_B（存在于进程B中）

因此，就好像您有四个独立的信号量（每个进程有一个互斥量 A 和一个互斥量 B），而不是预期的两个。

你想要的应该更多的是：

Semaphore sem1 = new Semaphore(1);
Semaphore sem2 = new Semaphore(1);

public class deadlockTest1 implements Runnable
{
    public void run()
    {
        sem1.acquire();
        Thread.sleep(1000);
        sem2.acquire();
    }
}

public class deadlockTest2 implements Runnable
{
    public void run()
    {
        sem2.acquire();
        Thread.sleep(1000);
        sem1.acquire();
    }
}

然后在你的主函数中：

public static void main(String[] args)
{
    deadlockTest1 tester1 = new deadlockTest1();
    deadlockTest2 tester2 = new deadlockTest2();
    tester1.run();
    tester2.run();
}

这应该完全按照我在第一个示例中描述的方式进行。当每个进程第一次运行时，它们都会成功获取自己的互斥锁（A锁sem1，B锁sem2），然后它们将休眠1秒。唤醒时，它们将尝试锁定另一个互斥锁（A 尝试锁定 sem2，B 尝试锁定 sem1），但由于这些资源从未被各自的进程释放，因此无法获取它们，因此这两个进程将无限期地阻塞。