Das zeigt ein einfaches Beispiel für deadlock mit Semaphoren

Ich bin derzeit die Betriebssysteme und unser Lehrer zugewiesen, dieses problem für unser Labor, aber er ist nicht sehr hilfreich. Also ich muss ein basic-Beispiel von deadlock mit Semaphoren und meine Ausgabe muss nachweisen, dass das auftreten von Deadlocks. Ich nehme an, er meint, wenn meine Ausnahme gefangen wird. Dies ist so nah wie ich bekommen habe. 

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

~

~

Bin ich noch in der Nähe? Ich lese material, aber noch nicht vollständig greifen. Ich glaube, ich verstehe nicht, was ein Prozess ist. Bitte jemand helfen.

  • Sie müssen zuerst verstehen, was ein deadlock ist. Eine InterruptedException geworfen wird, ist kein deadlock. Haben Sie googeln für "Java deadlock"? Wenn Sie hatten, würden Sie bekommen Erklärungen und Beispiele.
  • Ist ein deadlock, wenn Prozess 2 versucht auf Daten zuzugreifen, dass Prozess 1 nicht freigegeben hat. Gleichzeitig, Prozess-1 versucht, den Zugriff auf Daten, Prozess 2 nicht freigegeben hat. Ist das richtig? Ich verstehe einfach nicht, wie man einen Prozess, um zu versuchen, auf die Daten zugreifen.
InformationsquelleAutor user3736114 | 2014-06-16
  1. 4

    Tritt ein deadlock auf, wenn zwei oder mehrere Prozesse blockieren sich gegenseitig von der Vollendung der Ausführung. Sie können sich einen Prozess, da nur ein separates Programm; Sie laufen parallel mit der anderen Prozesse.

    Ein einfaches Beispiel für ein deadlock ist ein Programm mit zwei Prozessen und zwei Mutexe, wobei jeder Prozess muss der Zugriff auf beide Mutexe aber nicht freigegeben, es ist ein eigenes mutex, bis er erwirbt den anderen mutex. Ein Beispiel:

    1. Prozess Ein sperren Mutex Ein
    2. Prozess B locks Mutex B
    3. Prozess A möchte zu sperren Mutex-B aber bereits gesperrt durch Prozess B!
    4. Prozess B will lock Mutex Ein, hat aber bereits gesperrt durch die Prozess Ein!

    Hinweis: Ein mutex ist einfach eine semaphore mit dem Wert 1.

    Es ist leicht zu sehen, dies wird immer weiter, da weder Prozess-Freisetzung, die Ihre eigenen Ressourcen, bevor Sie die Verriegelung der anderen Ressource. Diese beiden Prozesse im deadlock.

    Das erste problem sehe ich mit deiner Implementierung ist, dass Sie geben jeden Prozess eine Reihe von Ihre EIGENEN Ampeln, das wird nicht funktionieren, denn Sie brauchen diese Semaphore freigegeben werden zwischen den Prozessen. Es ist, als wenn Sie dies getan haben:

    1. Prozess Ein sperren Mutex-A_A (existiert in Prozess A)
    2. Prozess B locks Mutex B_B (existiert in Prozess B)
    3. Prozess Ein sperren Mutex-B_A (existiert in Prozess A)
    4. Prozess B locks Mutex A_B (existiert in Prozess B)

    So ist es, als hätten Sie VIER seperate Semaphore (jeder Prozess hat eine Mutex-a-und Ein Mutex B) anstelle der vorgesehenen ZWEI.

    Was Sie wollen, sollte mehr entlang den Linien von:

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

    Dann in deiner main-Funktion:

    public static void main(String[] args)
{
    deadlockTest1 tester1 = new deadlockTest1();
    deadlockTest2 tester2 = new deadlockTest2();
    tester1.run();
    tester2.run();
}

    Dies sollte genau das tun, was ich beschrieben in meinem ersten Beispiel. Wenn jeder Prozess zuerst ausgeführt wird, wird jeder erfolgreich der Erwerb eigener Mutexe (Eine Sperre sem1, B-lock-sem2), dann werden Sie schlafen für 1 Sekunde. Auf wake up Sie wird bei jedem Versuch zum sperren der anderen mutex (Ein try-lock-sem2 -, B-versuchen sperren sem1), aber da diese Ressourcen wurden nie veröffentlicht, Ihre jeweiligen Prozesse, Sie kann nicht erworben werden und so sind diese beiden Prozesse blockieren.

    InformationsquelleAutor ewolfers
Schreibe einen Kommentar