java - 显示信号量死锁的简单示例

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();
    }   
}

~
~
我什至接近？我一直在阅读 Material ，但没有完全掌握它。我想我不明白什么是过程。有人请帮忙。

Answer 1

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

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

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

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

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

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

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

因此就好像您有 4 个独立的信号量(每个进程有一个 Mutex A 和一个 Mutex 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)，然后它们将 hibernate 1 秒。唤醒时，它们将各自尝试锁定另一个互斥量(A 尝试锁定 sem2，B 尝试锁定 sem1)，但由于这些资源从未被各自的进程释放，因此无法获取它们，因此这两个进程将无限期阻塞。