Come definire il thread safe array?

Question

Come si può definire un array globale thread-safe con modifiche minime?

Desidero che tutti gli accessi siano eseguiti utilizzando il mutex e il blocco sincronizzato.

Qualcosa di simile a questo come 'T' sarà un certo tipo (si noti che la parola chiave 'sync' non è attualmente definito per quanto ne so):

sync Array!(T) syncvar; 

E ogni accesso ad esso sarà simili a questo:

Mutex __syncvar_mutex; 

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

Answer 1

Avete l'idea giusta. Come array, devi essere in grado di modificare e recuperare informazioni. Suggerisco di dare un'occhiata alle utility read-write mutex e atomic fornite da Phobos. Un'operazione di lettura è abbastanza semplice:

1. synchronize su mutex.readLock
2. carico (con atomicLoad)
3. copiare l'elemento fuori dalla synchronize blocco
4. ritorno l'elemento copiato

scrittura dovrebbe essere quasi esattamente lo stesso Solo syncronize su mutex.writeLock e fare un'operazione cas o atomicOp.

Si noti che ciò funzionerà solo se si copiano gli elementi nell'array durante una lettura. Se si desidera ottenere un riferimento, è necessario eseguire un'ulteriore sincronizzazione sull'elemento ogni volta che si accede o si modifica.

Answer 2

Il mio tentativo ingenuo è stato quello di fare qualcosa di simile:

import std.typecons : Proxy: 

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

Purtroppo, non funziona a causa di https://issues.dlang.org/show_bug.cgi?id=14509

Non posso dire che sono molto sorpreso se la manipolazione come automagiche di multi- il threading tramite mutex nascosti è molto unidiomatico nella moderna D e il concetto stesso di classi sincronizzate è in gran parte un relitto di D1 volte.

È possibile implementare la stessa soluzione manualmente, ovviamente, definendo la propria classe SharedArray con tutti i metodi necessari e aggiungendo blocchi all'interno dei metodi prima di chiamare i metodi interni privati ​​di plain Array. Ma presumo che tu voglia qualcosa che funzioni di più fuori dagli schemi.

Impossibile inventare qualcosa di meglio qui e ora (ci penserò di più) ma vale la pena notare che in generale è incoraggiato in D creare strutture dati progettate per gestire l'accesso condiviso in modo esplicito invece di proteggere solo i dati normali strutture con mutex. E, naturalmente, l'approccio più incoraggiato è quello di non condividere i dati con il passare del messaggio.

aggiornerò la risposta se mi viene in mente qualcosa di meglio.

Answer 3

È possibile racchiudere la matrice all'interno di una struttura che blocca l'accesso all'array quando un thread acquisisce un token e finché non lo rilascia.

L'involucro/armadio:

• acquire(): viene chiamato in cicli di un filo. Quando restituisce un puntatore, il thread sa che ha il token quando il metodo restituisce un valore non nullo.
• release(): viene chiamato da una discussione dopo aver elaborato i dati il ​​cui accesso è stato acquisito in precedenza.

.

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

e un breve prova:

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

Con l'inconveniente che ciascun blocco di operazione sulla matrice deve essere circondato da un acquisire/rilascio coppia.

Answer 4

È abbastanza semplice creare un wrapper attorno all'array che lo renderà thread-safe. Tuttavia, è estremamente difficile creare un array thread-safe che non sia un collo di bottiglia di concorrenza.

La cosa più vicina che viene in mente è la classe di Java CopyOnWriteArrayList, ma anche questo non è l'ideale ...