bloqueo en una variable en múltiples hilos

Question

soy muy nuevo en C# y quería preguntarle si tengo esta situación en MULTI HILOS (pseudo código):

public class ClassA 
{ 
    ClassB c = new ClassB(); 
    public void someMethod() 
    { 
      c.myVar = 1; 
      // Some other stuff 
      c.myVar = 0; 
    } 
} 

public class ClassB 
{ 
    private int myVar; 

    public void MethodA() 
    { 
     if(myVar = 1) 
       myVar = 0; 
    } 
} 

Si algunMetodo() y MethodA() puede estar activo en hilos separados, entonces MethodA() podría evaluar el enunciado if como verdadero; pero antes de establecer myVar = 0 someMethod establece myVar = 0 por lo que es incorrecto haber establecido myVar en 0 en MethodA() !!

Básicamente, ¿cómo bloqueo myVar: puedo bloquear {} en la propiedad de myVar (establecer, obtener) o necesito usar Interlock (aún no tengo experiencia de Interlock)?

Answer 1

Así es como lo hago.

static readonly object _myVar_Lock = new object(); 
    private int _myVar = 0; 

    public int myVar 
    { 
     get { lock (_myVar_Lock) { return this._myVar; } } 
     set { lock (_myVar_Lock) { this._myVar = value; } } 
    } 

Answer 2

¿Hay alguna razón para que haya múltiples hilos que comparten la misma instancia de la clase en lugar de implementar cada hilo de modo que consiga su propia instancia de la clase dentro de su alcance?

Answer 3

Parece que está intentando implementar algún tipo de mecanismo de señalización. En lugar de escribir el suyo, puede usar una de las clases proporcionadas en la biblioteca .NET como ManualResetEvent.

Answer 4

Debe crear un objeto privado que permitirá el bloqueo:

private readonly object _locker = new object(); 

Luego, en su propiedad métodos get/set, bloqueo alrededor de él:

get { lock (_locker) { return this.myVar; } } 
set { lock (_locker) { this.myVar = value; } } 

Asegúrese de que su método utiliza la cerradura también:

public void MethodA() 
{ 
    lock(_locker) 
    { 
     if(myVar == 1) 
      myVar = 0; 
    } 
} 

Answer 5

Sin duda volvería a pensar en su enfoque general, pero si desea Para sincronizar el acceso a los miembros de ClassB desde diferentes secciones de código, entonces podría robar un patrón de diseño no tan bueno de la interfaz ICollection y exponer una propiedad SyncRoot que se puede usar para adquirir el mismo bloqueo que la instancia original.

public class ClassA 
{ 
    private ClassB c = new ClassB(); 

    public void someMethod() 
    { 
    lock (c.SyncRoot) 
    { 
     c.MyVar = 1; 
     // Some other stuff 
     c.MyVar = 0; 
    } 
    } 
} 

public class ClassB 
{ 
    private object m_LockObject = new object(); 
    private int m_MyVar; 

    public object SyncRoot 
    { 
    get { return m_LockObject; } 
    } 

    public int MyVar 
    { 
    get { lock (SyncRoot) return m_MyVar; } 
    set { lock (SyncRoot) m_MyVar = value; } 
    } 

    public void MethodA() 
    { 
    lock (SyncRoot) 
    { 
     if (m_MyVar == 1) m_Var = 0; 
    } 
    } 
}