C＃锁关键字的用法

Question

我发布我对C＃锁的理解如下，请帮助我验证我是否正确。

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

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

案例I>线程1和线程同时试图调用PrintOne。 由于PrintOne由实例锁保护，因此在任何时候，只有一个线程可以专门进入SectionOne。

这是正确的吗？

案例二>线程1和线程同时尝试分别拨打PrintOne和PrintTwo （即线程1调用PrintOne及线程调用PrintTwo） 由于两个打印方法是由同一个实例锁保护，在任何时候， 只有一个线程可以独占访问SectionOne或SectionTwo，但不能同时访问两者。

这是正确的吗？

Answer 1

是的，是的。案件是正确的。

Answer 2

案例一：检查✓

案例二：检查✓

不要忘了锁是线程同步的一种方式。对于其他userfull方法，请阅读：Thread Synchronization

直接从MSDN样本：

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

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

Answer 3

是的，你在这两个方面是正确的。

Answer 4

你的理解是100％正确的。因此，例如，如果你想允许分别进入两种方法，你会想要两个锁。

Answer 5

1和2 真的只有如果所有的线程使用类的相同实例。如果他们使用不同的实例，那么这两种情况假

样品

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

并测试代码

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

一个可能的解决方案是一个静态的关键字添加到锁定对象声明和使用它的方法。

private static object threadLock = new object(); 

UPDATE 好一点的konrad.kruczynski

做...... “线程安全” 也从 方面承担。例如，我可以采取 您的文件开放代码，并且 生成异常与静态锁 - 只需要另一个应用程序 域。因此建议OP 应该使用全系统互斥类或 这样的。因此，静态情况 只是推断为实例一。

Answer 6

这里是基本知识（或多或少）

1）使用实例锁例如数据

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

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

2）使用静态数据

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

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

3静态锁）如果您保护静态数据和实例数据使用单独的静态和实例锁

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

在此基础上你的代码是好的，如果你正在访问实例数据，但不安全的，如果你正在修改静态数据