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

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)，但由于这些资源从未被各自的进程释放，因此它们无法被获取，因此这两个进程将无限期阻塞。