Blocco di proprietà, buon approccio?

Question

Nella mia applicazione multithreading sto usando alcune variabili che possono essere modificate da molte istanze nello stesso tempo. È strano ma ha funzionato bene senza alcun problema..ma ovviamente ho bisogno di renderlo thread-safe. Sto solo cominciando con le serrature quindi consiglioi il tuo consiglio:

Quando il client si connette, viene creato il client di classe in cui ogni client ha la propria variabile "A".

A volte, client chiama il metodo del genere:

Client selectedClient SelectOtherClientClassByID(sentID); 

selectedClient.A=5; 

Nessun problema fino ad ora con che anche quando 5 classi stavano facendo al tempo stesso (threadpool), ma stavo pensando che dire di aggiungere blocchi per A Proprietà ?

come:

A { 
    get { return mA; } 
    set { 
     // use lock here for settting A to some value 
    }  
} 

sarebbe OK?

Answer 1

È necessario utilizzare i blocchi in ENTRAMBI ottenere e impostare. Questo blocco deve essere lo stesso oggetto. Ad esempio:

private object mylock = new object(); 

public int A { 

    get { 
    int result; 
    lock(mylock) { 
    result = mA; 
    } 
    return result; 
    } 

    set { 
    lock(mylock) { 
     mA = value; 
    } 
    } 
} 

Answer 2

È molto raro quando tutto ciò che serve è impostare solo una proprietà. Più spesso, selectedClient.A = 5 farà parte di un'operazione logica molto più grande, che comporta diversi incarichi/valutazioni/ecc. Durante l'intera operazione preferiresti preferire che lo selectedClient sia in uno stato coerente e non introdurre condizioni di gara/deadlock. Pertanto, sarà molto meglio per esporre SyncRoot proprietà nella classe Client e blocco su che dal codice chiamante:

Client selectedClient = GetClient(...); 

lock(selectedClient.SyncRoot) 
{ 
    selectedClient.A = 5; 
    selectedClient.B = selectedClient.A * 54; 
} 

Answer 3

bloccando l'accesso alle proprietà all'interno di funzioni di accesso può portare a risultati falsi. Per l'esempio, osservare il seguente codice:

class C { 
    private object mylock = new object(); 

    public int A { 

     get { 
     int result; 
     lock(mylock) { 
     result = mA; 
     } 
     return result; 
     } 

     set { 
     lock(mylock) { 
      mA = value; 
     } 
     } 
    } 
} 
C obj = new C; 
C.A++; 

(sì, ho copiato dalla prima risposta) C'è una condizione di competizione qui! L'operazione "C.A ++" richiede in realtà due accessi separati ad A, uno per ottenere il valore e l'altro per impostare il valore aggiornato. Niente garantisce che questi due accessi vengano eseguiti insieme senza che il contesto passi tra di essi. Scenario classico per condizioni di gara!

Quindi, attenzione! Non è una buona idea mettere i lucchetti dentro gli accessor, i lock dovrebbero essere esplicitamente ottenuti, come suggerisce la risposta precedente (anche se non deve essere con SyncRoots, qualsiasi oggetto lo farà)