Hey, ich gehe grad ein paar Übungen zum Thema Paralleles Rechnen etc durch. In folgendem Abschnitt ist wohl ein potentieller Deadlock vorhanden:
Ich weiß die Objekte sind nicht initialisiert, aber nehmen wir mal an es wäre so:
public class ResourcePool<T> {
private List<T> pool;
private Semaphore semaphore;
public synchronized void release(T resource) {
pool.add(resource);
semaphore.release();
}
public synchronized T require() throws InterruptedException {
semaphore.acquire();
return pool.remove(0);
}
}```
und
public class Semaphore {
private volatile int free;
public Semaphore(int size) {
free = size;
}
public synchronized void release() {
free++;
notify();
}
public synchronized void acquire() {
while (free <= 0) {
try {
wait();
} catch (InterruptedException e) { /* ignore */
e.printStackTrace();
}
}
free--;
}
}```
Sooo, ich sehe, dass man jetzt praktisch 2 Locks hat, wobei man wahrscheinlich nur einen bräuchte.
Ein Deadlock könnte ja jetzt dadurch passieren, dass sich ein Thread am Semaphore locked, und ein anderer am ResourcePool und die sich irgendwie gegenseitig verklemmen.
Allerdings sehe ich nicht wirklich, wie das passieren kann, da sich ein Thread ja nur am Semaphore locken kann, wenn er schon den ResourcePool-Lock hat.
Hab da gestern länger drangesessen und es nicht wirklich gefunden. Vllt kann mir jemand sagen, wo da ein potentieller Deadlock ist?
Meine Vermutung wäre jetzt gewesen, dass sich ein Thread den ResourcePool-Lock “holt”, dann den Semaphore-Lock, und sich dann in der acquire-Methode des Semaphores “schlafen legt”.
Dann gibt er den Lock auf den Semaphore praktisch ab, hat aber immer noch den Lock auf den ResourcePool. Somit kann ein anderer Thread garnicht erst den Lock des Semaphores “bekommen” und die notify-Methode aufrufen.
Das wäre jetzt meine Vermutung, allerdings weiß ich nicht ganz genau, wie das mit den Locks läuft bei wait() etc.
Vllt kann mir da jemand helfen.
Grüße