Threads Semaphore, Deadlocks

[MaNana]

Hallo,
könnte mir jemand sagen, ob es im folgenden Code zu Deadlocks kommen kann und wenn ja erklären wie diese zustandekommt?

public class SynchronisationsTest{
  public static void main(String [ ] args){
      Semaphore [ ] ressourcen = new Semaphore(3);
      resourcen [0] = new Semaphore(1);
      ressourcen [1] = new Semaphore(1);
      ressourcen [2] = new Semaphore(1);
      ReentrantLock lock = new ReentrantLock();
      RessourcenThread [] threads = new RessourcenThread();
        threads [0] = new RessourcenThread(ressourcen[0], ressourcen[1], lock);
        threads [1] = new RessourcenThread(ressourcen[1], ressourcen[2], lock);
        threads [2] = new RessourcenThread(ressourcen[2], ressourcen[0], lock);
     
        for (RessourcenThread thread : threads){
            thread.start();
        }
        ...
    }
}
public class RessourcenThread extends Thread{
    private Semaphore ressource1; // binärer Semaphore
    private Semaphore ressource2; // binärer Semaphore
    private ReentrantLock lock;
    public RessourcenThread (Semaphore ressource1, Semaphore ressource2, ReentrantLock lock){
        this.ressource1 = ressource1;
        this.ressource2 = ressource2;
        this.lock = lock;
    }
    public void run{
        try{
            lock.lock();
            ressource1.acquire();
            ressource2.acquire();
            lock.unlock();
         
            // mache irgendetwas kritisches mit den Ressourcen
            ...
         
            lock.lock();
            ressource1.release();
            ressource2.release();
            lock.unlock();
        }
        catch(InterruptedException e) {}
    }
}

 

[Thallius]

Deadlock eigentlich nicht aber das Konsrtukt ist ziemlich sinnlos, da niemals mehr als ein Thread gleichzeitig laufen kann. Also kannst du es auch gleich in einen Thread machen.

Gruß

Claus

 

[InfectedBytes]

Es kann schon zum deadlock kommen.
Der erste Thread holt sich den lock, und sichert sich semaphore 0 und 1, gibt den lock dann wieder frei.
Dann kommt der nächste thread an, holt sich den lock und versucht semaphore 1 und 2 zu erhalten, da semaphore 1 aber schon vom anderen thread benutzt wurde, blockiert dieser thread, behält aber den lock.
=> Die anderen Threads blockieren wenn sie sich den lock holen wollen, dieser wird aber nie freigegeben, da ein thread auf die freigabe eines semaphores wartet.

 

[InfectedBytes]

Außerdem solltest du die Locks besser im Zusammenhang mit Conditions verwenden.