我是否正确理解了资源分配的概念?
Am I understanding the concept of resource allocation correctly?
我对 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的节点意味着进程锁定了资源。
我理解正确吗?
欢迎任何帮助。
谢谢。
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,你会知道它已经达到死锁。
我对 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的节点意味着进程锁定了资源。
我理解正确吗? 欢迎任何帮助。 谢谢。
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,你会知道它已经达到死锁。