Wie deklariert Shared Variable bei der Verwendung mehrerer Threads in Java keine Semaphore

Question

Ich habe ein Projekt für meine Betriebssystem-Klasse, in der wir ein Programm schreiben müssen mit mehreren Threads und keine Semaphoren, ich verstehe, wie man es in Pseudo-Code aber Wenn ich über die Implementierung nachdenke, kann ich nicht herausfinden, wie man eine gemeinsame Variable deklariert. Alles, was ich mir vorstellen kann, ist ein anderer Thread, der alle Variablen enthält. Edit 1: wir müssen while verwenden (busywait true) {}

bearbeiten 2: Durch seine Implementierung wird dieses Projekt Sie mit der Erstellung und Ausführung von Threads und mit der Verwendung der Thread-Klassenmethoden vertraut machen. Um die Threads zu synchronisieren, müssen Sie verwenden (wenn nötig), run(), start(), currentThread(), getName(), join(), yield(), sleep (time), isAlive() , getPriority(), setPriority(), interrupt(), isInterrupted(), vielleicht synchronisierte Methoden. Verwenden Sie bei der Synchronisation von Threads KEINE Semaphoren. Verwenden Sie nicht wait(), notify() oder notifyAll();

Answer 1

Jede Instanz der Runnable-Implementierung enthält eine Referenz auf dieselbe gemeinsame Variable. Damit Änderungen an der Variablen für alle anderen Threads sichtbar sind, ist eine Synchronisierung erforderlich. Die Variable sollte entweder als flüchtig deklariert werden oder auf sie sollte nur in synchronisierten Blöcken zugegriffen werden.

class X implements Runnable{ 

    private int sharedVariable; 

    public X(int shared){ 
      sharedVariable = shared; 
    } 
    public void run(){ 
    . . . 
    } 
} 

public static void main(String args[]){ 

    int shared = 5; 
    Thread t1 = new Thread(new X(shared)); 
    Thread t2 = new Thread(new X(shared)); 

    t1.start(); 
    t2.start(); 
} 

Answer 2

Korrekte Multithreading-Programmierung setzt die Verwendung einer Art von Synchronisationseinrichtung voraus. Jede Synchronisationseinrichtung kann nur mit einer anderen Synchronisationseinrichtung erstellt werden. Die Synchronisationseinrichtung der niedrigsten Ebene ist eine Speicherzelle, auf die mit dem Befehl zum Vergleichen und Setzen des Prozessors zugegriffen wird. In Java entsprechen AtomicInteger.compareAndSet (int expectedValue, int newValue) und analoge Methoden anderer atomarer Klassen diesem Befehl.