Wie definiere ich ein Thread-sicheres Array?

Question

Wie kann ich ein Thread-sicheres globales Array mit minimalen Änderungen definieren?

Ich möchte wie jeder Zugriff darauf mit Mutex und synchronisierten Block erreicht werden.

So etwas wie ‚T‘ wird eine Art sein (beachten Sie, dass ‚sync‘ Schlüsselwort ist nicht AFAIK definiert ist):

sync Array!(T) syncvar; 

Und jeder Zugriff darauf wird diese simmilar sein:

Mutex __syncvar_mutex; 

    //some func scope.... 
    synchronized(__syncvar_mutex) { /* edits 'syncvar' safely */ } 

Answer 1

Sie haben die richtige Idee. Als Array müssen Sie Informationen bearbeiten und abrufen können. Ich schlage vor, dass Sie sich die von Phobos zur Verfügung gestellten Dienstprogramme read-write mutex und atomic ansehen. Ein Lesevorgang ist recht einfach:

1. synchronize auf mutex.readLock
2. Last (mit atomicLoad)
3. das Element kopieren
aus dem synchronize Block
4. Rückkehr der kopierte Element

Schreiben sollte sei fast genau gleich. Just syncronize auf mutex.writeLock und tun Sie einen cas oder atomicOp Operation.

Beachten Sie, dass dies nur funktioniert, wenn Sie die Elemente im Array während eines Lesevorgangs kopieren. Wenn Sie eine Referenz erhalten möchten, müssen Sie jedes Mal, wenn Sie auf das Element zugreifen oder es ändern, eine zusätzliche Synchronisierung für das Element durchführen.

Answer 2

Mein naiver Versuch war, so etwas zu tun:

import std.typecons : Proxy: 

synchronized class Array(T) 
{ 
    static import std.array; 
    private std.array.Array!T data; 
    mixin Proxy!data; 
} 

Leider funktioniert es nicht wegen https://issues.dlang.org/show_bug.cgi?id=14509

Kann ich nicht sagen, dass mir sehr überrascht, obwohl als automagischen Umgang mit multi- Threading über versteckte Mutexe ist in modernen D sehr unidiomatisch und das Konzept synchronisierter Klassen ist meist ein Relikt aus D1-Zeiten.

Sie können die gleiche Lösung natürlich manuell implementieren, indem Sie eine eigene SharedArray Klasse mit allen notwendigen Methoden definieren und Sperren innerhalb der Methoden hinzufügen, bevor Sie interne private einfache Methoden aufrufen Array. Aber ich nehme an, Sie wollen etwas, das mehr aus der Box funktioniert.

Kann nichts besseres hier und jetzt erfinden (wird mehr darüber nachdenken), aber es ist erwähnenswert, dass es in D im Allgemeinen ermutigt wird, Datenstrukturen für den expliziten Umgang mit gemeinsamem Zugriff zu erstellen, statt nur normale Daten zu schützen Strukturen mit Mutexen. Und natürlich ist der am meisten unterstützte Ansatz, keine Daten gemeinsam zu nutzen, sondern stattdessen die Nachrichtenübermittlung zu verwenden.

Ich werde die Antwort aktualisieren, wenn etwas besser in meinen Sinn kommt.

Answer 3

Sie können das Array innerhalb einer Struktur umschließen, die den Zugriff auf das Array sperrt, wenn ein Thread ein Token erwirbt und bis es es freigibt.

Die Hülle/Locker:

• acquire(): wird in Schleife durch einen Thread bezeichnet. Wenn ein Zeiger zurückgegeben wird, weiß der Thread, dass er das Token hat, wenn die Methode einen Nicht-Null-Wert zurückgibt.
• release(): wird von einem Thread nach der Verarbeitung der Daten aufgerufen, deren Zugriff zuvor erworben wurde.

.

shared struct Locker(T) 
{ 
    private: 
     T t; 
     size_t token; 
    public: 
     shared(T) * acquire() 
     { 
      if (token) return null; 
      else 
      { 
       import core.atomic; 
       atomicOp!"+="(token, 1); 
       return &t; 
      } 
     } 
     void release() 
     { 
      import core.atomic; 
      atomicOp!"-="(token, 1); 
     } 
} 

und ein Schnelltest:

alias LockedIntArray = Locker!(size_t[]); 
shared LockedIntArray intArr; 

void arrayTask(size_t cnt) 
{ 
    import core.thread, std.random; 

    // ensure the desynchronization of this job. 
    Thread.sleep(dur!"msecs"(uniform(4, 20))); 

    shared(size_t[])* arr = null; 
    // wait for the token 
    while(arr == null) {arr = intArr.acquire;} 

    *arr ~= cnt;  
    import std.stdio; 
    writeln(*arr); 

    // release the token for the waiting threads 
    intArr.release; 
} 

void main(string[] args) 
{ 
    import std.parallelism; 
    foreach(immutable i; 0..16) 
    { 
     auto job = task(&arrayTask, i); 
     job.executeInNewThread(); 
    } 
} 

Mit dem Nachteil, dass jeder Block der Betrieb über die Anordnung muss mit einem acquire/Release Paar umgeben sein.

Answer 4

Es ist ziemlich einfach, einen Wrapper um ein Array zu erstellen, der es threadsicher macht. Es ist jedoch äußerst schwierig, ein thread-sicheres Array zu erstellen, das keinen Nebenläufigkeitsengpass darstellt.

Die nächste Sache, die den Sinn kommt, ist CopyOnWriteArrayList Klasse Java, aber auch das ist nicht ideal ...