C# lock 关键字的使用

Question

我对C#锁的理解如下，请帮我验证一下是否正确。

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

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

案例 I> Thread1 和 Thread2 同时尝试调用 PrintOne。 由于 PrintOne 受到实例锁的保护，在任何时候，只有 一个线程可以独占进入SectionOne。

这是正确的吗？

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

这是正确的吗？

Answer 1

如果您的所有线程都使用类的相同实例，

1 和 2 仅 为真。如果他们使用不同的实例，那么这两种情况都是false

样本

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

更新 konrad.kruczynski 提出的好观点

...“线程安全”也被假定为 语境。例如，我可以采取 您的文件打开代码以及 使用静态锁生成异常 - 只是采取另一个应用程序 领域。因此建议 OP 应该使用系统范围的 Mutex 类或 那样的。因此静态情况 只是推断为实例之一。

Answer 2

案例一：检查✓

案例二：检查✓

不要忘记锁定只是线程同步的一种方式。对于其他用户方法，请阅读：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

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

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

基于此，如果您正在访问实例数据，则您的代码很好，但如果您正在修改静态数据，则不安全