Uso de la palabra clave de bloqueo C#

Question

Publico mi comprensión del bloqueo de C# de la siguiente manera, ayúdenme a validar si lo hago bien o no.

public class TestLock 
{ 
    private object threadLock = new object(); 
    ... 
    public void PrintOne() 
    { 
     lock (threadLock) 
     { 
      // SectionOne 
     } 
    } 

    public void PrintTwo() 
    { 
     lock (threadLock) 
     { 
      // SectionTwo 
     } 
    } 
    ... 
} 

Caso I> Thread1 y Thread2 al mismo tiempo trato de llamar Printone. Dado que PrintOne está protegido por el bloqueo de instancia, en cualquier momento, solo un hilo puede entrar exclusivamente en SectionOne.

¿Es esto correcto?

Caso II> Thread1 y Thread2 al mismo tiempo tratar de llamar Printone y PrintTwo respectivamente (es decir Thread1 llama Printone y Thread2 llama PrintTwo) ya que dos métodos de impresión son vigiladas por la misma cerradura ejemplo, en cualquier momento, solo un hilo puede acceder de forma exclusiva a SectionOne o SectionTwo, pero NO a ambos.

¿Es esto correcto?

Answer 1

Sí y sí. Los casos son correctos.

Answer 2

Caso I: Marque ✓

Caso II: Asegúrate ✓

No se olvide que el bloqueo es sólo una forma de sincronización de subprocesos. Para otros métodos userfull, debe decir: Thread Synchronization

Directamente de la muestra de MSDN:

public class TestThreading 
{ 
    private System.Object lockThis = new System.Object(); 

    public void Process() 
    {  
     lock (lockThis) 
     { 
      // Access thread-sensitive resources. 
     } 
    }  
} 

Answer 3

Sí, tiene usted razón en ambos casos.

Answer 4

Tu conocimiento es 100% correcto. Entonces, si, por ejemplo, desea permitir la entrada en los dos métodos por separado, le conviene tener dos bloqueos.

Answer 5

1 y 2 son verdadero solo si todos sus hilos usan la misma instancia de la clase. Si utilizan instancias diferentes, a continuación, ambos casos son falsa

Muestra

public class TestLock 
{ 
    private object threadLock = new object(); 

    public void PrintOne() 
    { 
     lock (threadLock) 
     { 
      Console.WriteLine("One"); 
      var f = File.OpenWrite(@"C:\temp\file.txt"); //same static resource 
      f.Close(); 
     } 
    } 

    public void PrintTwo() 
    { 
     lock (threadLock) 
     { 
      Console.WriteLine("Two"); 
      var f = File.OpenWrite(@"C:\temp\file.txt"); //same static resource 
      f.Close(); 
     } 
    } 
} 

Y código de prueba

static void Main(string[] args) 
{ 
    int caseNumber = 100; 

    var threads = new Thread[caseNumber]; 
    for (int i = 0; i < caseNumber; i++) 
    { 
     var t = new Thread(() => 
           { 
            //create new instance 
            var testLock = new TestLock(); 
            //for this instance we safe 
            testLock.PrintOne(); 
            testLock.PrintTwo(); 
           }); 
     t.Start(); 
     //once created more than one thread, we are unsafe 
    } 
} 

Una de las posibles soluciones es añadir una palabra clave estática a la declaración de objeto de bloqueo y métodos que lo utilizan.

private static object threadLock = new object(); 

ACTUALIZACIÓN Buen punto hecha por konrad.kruczynski

... "hilo de seguridad", también se asume desde contexto.Por ejemplo, podría tomar su código de apertura de archivo y también generar excepción con bloqueo estático - simplemente tomando otra aplicación dominio. Y, por lo tanto, propongo que OP use clase Mutex en todo el sistema o así. Por lo tanto, el caso estático se deduce como el de instancia.

Answer 6

aquí están los fundamentos (más o menos)

1) utilizar bloqueos de instancia para datos de instancia

public class InstanceOnlyClass{ 
    private int callCount; 
    private object lockObject = new object(); 

    public void CallMe() 
    { 
     lock(lockObject) 
     { 
      callCount++; 
     } 
    } 
} 

2) utilizar bloqueos estáticos para datos estáticos

public class StaticOnlyClass{ 
    private int createdObjects; 
    private static object staticLockObject = new object(); 

    public StaticOnlyClass() 
    { 
     lock(staticLockObject) 
     { 
      createdObjects++; 
     } 
    } 
} 

3) si está protegiendo datos estáticos y de instancia, utilice bloqueos estáticos y de instancia separados

public class StaticAndInstanceClass{ 
    private int createdObjects; 

    private static object staticLockObject = new object(); 

    private int callCount; 

    private object lockObject = new object(); 

    public StaticAndInstanceClass() 
    { 
     lock(staticLockObject) 
     { 
      createdObjects++; 
     } 
    } 

    public void CallMe() 
    { 
     lock(lockObject) 
     { 
      callCount++; 
     } 
    } 
} 

en base a este código es muy bien si usted está accediendo a datos de instancia, pero no seguro si está modificando los datos estáticos