我是否正确理解了资源分配的概念？

Question

我对 synchronized 在 Java 中如何进行资源分配感到困惑。当我在 Java 中收到以下代码时：

import java.util.concurrent.Semaphore;

public class Deadlock {
public Deadlock () {
    Semaphore mutex[] = new Semaphore[4];

    for (int i = 0; i < 4; i++) 
        mutex[i] = new Semaphore(1);

    A threadA = new A(mutex);
    B threadB = new B(mutex);
    C threadC = new C(mutex);

    threadA.start();
    threadB.start();
    threadC.start();
}

private class A extends Thread {
    private Semaphore[] resource;

    public A(Semaphore[] m) {
        resource = m;
    }

    public void run() {
        System.out.println("A started");
        synchronized( resouce[1] ) {
            System.out.println("A locks rsc 1");
            synchronized (resource[0]) {
                System.out.println("A locks rsc 0");
            }
        }
        System.out.println("A finished");
    }
}
private class B extends Thread {
    private Semaphore[] resource;

    public B(Semaphore[] m) {
        resource = m;
    }

    public void run() {
        System.out.println("B started");
        synchronized( resouce[3] ) {
            System.out.println("B locks rsc 3");
            synchronized (resource[0]) {
                System.out.println("B locks rsc 0");
                synchronized (resource[2]) {
                    System.out.println("B locks rsc 2");
                }
            }
        }
        System.out.println("B finished");
    }
}
private class C extends Thread {
    private Semaphore[] resource;

    public C(Semaphore[] m) {
        resource = m;
    }

    public void run() {
        System.out.println("C started");
        synchronized( resouce[2] ) {
            System.out.println("C locks rsc 2");
            synchronized (resource[1]) {
                System.out.println("C locks rsc 1");
            }
        }
        System.out.println("C finished");
    }
}
}

据我了解，当线程A启动时，线程A锁定了资源1和资源0。因此，当线程 B 启动时，它会获取资源 3 上的锁，但会等待资源 0 从线程 A 中释放。由于线程 B 没有资源 0 上的锁，因此它无法等待资源 2。当线程 C 启动时，它会锁定资源 2，但也会等待资源 1 从线程 A 中释放。

所以，当它绘制成资源分配图时，它会是这样的：

这里的节点P到R指的是请求资源的进程。并且从R到P的节点意味着进程锁定了资源。

我理解正确吗？欢迎任何帮助。谢谢。

Answer 1

when Thread B starts, it will acquire lock on resource 3, but will be waiting on resource 0 to be released from Thread A

啊，但这假设 A 仍然是运行ning。它可能已经完成，也可能还没有开始。您遇到死锁条件的机会可能只发生在运行的千分之一中。这是线程的本质，它们运行异步、并发。很难预测它们的精确行为。

此外，您通过调用 System.out.println(...) 来使事情复杂化，它也在进行同步。这会中断您的测试并改变竞争条件。

Am I understanding this correctly?

我认为您对资源图的理解很恰当，只是没有在正确的时间达到完美的死锁点有多难。

可以尝试的一件事是在 while(true) 循环中执行以下操作。

while (true) {
   A threadA = new A(mutex);
   B threadB = new B(mutex);
   C threadC = new C(mutex);
   threadA.start();
   threadB.start();
   threadC.start();
   threadA.join();
   threadB.join();
   threadC.join();
}

在某个时候输出会停止，CPU 会变为 0，你会知道它已经达到死锁。

我是否正确理解了资源分配的概念？

Am I understanding the concept of resource allocation correctly?

java

process

resources

deadlock

synchronized