CreateSemaphore()

Syntax

Semaphore = CreateSemaphore([Anfangszähler])

Erstellt ein neues Semaphore-Objekt.

Ein Semaphore ist ein Thread-Synchronisations-Objekt, welches einen internen Zähler einschließt. Es hat zwei Arten von Operationen: Signal und Warten. Eine Warte-Operation vermindert den Zähler des Semaphore um eins. Wenn der Zähler unter 0 fallen würde, dann blockiert die Warte-Operation bis ein Signal-Aufruf erfolgt. Eine Signal-Operation erhöht den Zähler um eins, und gibt (wenn vorhanden) einen blockierten Thread wieder frei. Ein Semaphore ermöglicht das Erzwingen von minimalen und maximalen Zählern gegenüber Threads, zum Beispiel um zu vermeiden, dass einem Queue (Warteschleife) die Elemente ausgehen oder er zu viele Elemente erhält.

Anders als ein Mutex ist ein Semaphore-Objekt nicht "im Besitz" eines bestimmten Threads, was bedeutet dass Signal/Warte-Aufrufe nicht vom gleichen Thread erfolgen müssen, wie dies mit LockMutex() und UnlockMutex() der Fall ist. Tatsächlich ist die gebräuchliche Nutzungsweise eines Semaphore-Objekts, durch einen Thread die SignalSemaphore() Aufrufe durchzuführen und durch einen weiteren Thread alle WaitSemaphore() Aufrufe durchzuführen, um eine Hersteller/Konsument-Struktur (englisch: "producer/consumer pattern") zu schaffen.

Parameter

Anfangszähler (optional)

Dies muss ein positiver Wert sein, welcher den anfänglichen Zähler des Semaphore definiert. Wenn dieser nicht angegeben wird, lautet der anfängliche Zähler gleich 0.

Rückgabewert

Das neue Semaphore-Objekt - oder Null, wenn die Semaphore-Erstellung fehlgeschlagen ist.

Beispiel

Dieses Beispiel zeigt einen "Hersteller" Thread, welcher ein Queue mit Elementen bevölkert und dem Haupt-Thread, der sie liest. Das Semaphore wird verwendet, um sicher zu gehen, dass dem Queue nie die Elemente ausgehen. Beachten Sie, dass dies auch erreicht werden kann, mit nur einem Mutex und Warten/Abfragen von Queue-Elementen mit einem Delay() zwischendrin, aber die Semaphore-Befehle führen ein effizienteres Warten aus (kehren umgehend nach einem SignalSemaphore() Aufruf zurück, und nicht nur wenn das nächste Mal eine Abfrage-Schleife den Queue überprüft).

Global Semaphore = CreateSemaphore()
Global Mutex     = CreateMutex()
Global NewList Queue()

Procedure Producer(Total)

  For i = 1 To Total
    Delay(Random(750) + 250)
    
    ; Der Queue-Zugriff benötigt weiterhin einen normalen "Mutex Lock", um Thread-sicher zu sein
    LockMutex(Mutex)
      LastElement(Queue())
      AddElement(Queue())
      Queue() = i
    UnlockMutex(Mutex)    

    ; Signalisiere, dass es ein neues Queue-Element gibt
    SignalSemaphore(Semaphore)
  Next i
    
EndProcedure

If CreateThread(@Producer(), 30)

  For i = 1 To 30  
    ; Warte auf ein verfügbares Element
    WaitSemaphore(Semaphore)
    
    ; Queue-Status anzeigen
    LockMutex(Mutex)
      Queue$ = "Queue:"
      ForEach Queue()
        Queue$ + " " + Str(Queue())
      Next Queue()
      Debug Queue$
    
      ; Kopf-Element vom Queue entfernen
      FirstElement(Queue())
      DeleteElement(Queue())
    UnlockMutex(Mutex)
    
  Next i

EndIf

Siehe auch

FreeSemaphore()

Unterstützte OS

Alle