Question

我想创建这个类的多个实例。

public class Worker
{
    private object _lockObject;
    private Thread _workerThread;
    private string _name;

    public Worker(object lockObject, string name)
    {
        _name = name;
        _lockObject = lockObject;
        _workerThread = new Thread(new ThreadStart(DoWork));
        _workerThread.Start();
    }
    private void DoWork()
    {
        while(true)
        {
            lock(_lockObject)
            {
                Console.WriteLine(_name + "Doing Work");
            }
        }
    }
}

如果我将同一个锁对象传递给该类的多个实例，那么一个类实例中的锁是否会导致另一个类实例等待该锁被释放？

static void Main()
{
    private readonly object sharedLockObject = new object();
    Worker a = new Worker(sharedLockObject,"a");
    Worker b = new Worker(sharedLockObject,"b");
    Console.ReadLine();
}

我认为在上述案例中，工人永远不会： Console.WriteLine（_name +“正在工作”）; 在同一时间？

我只是想要一些确认，因为我不确定lock（）是否会锁定引用或引用的对象。

谢谢！

Answer 1

是的，object是一个引用类型，因此您要传递对同一对象的引用，以便每个Worker使用相同的对象。该对象用于锁定，而不是引用。

Answer 2

lock语句将标记对象实例，而不是引用变量。

lock(x) {
   ...
}

完全等同于：

System.Threading.Monitor.Enter(x);
try {
   ...
}
finally {
   System.Threading.Monitor.Exit(x);
}

其中x是引用类型的对象实例。

是的： - ）

Answer 3

我建议你不要传递用于锁定的共享对象，否则你可能会遇到一些讨厌的死锁。使用该类的静态私有成员来锁定：

public class Worker
{
    private static object _syncRoot = new object();
    private Thread _workerThread;
    private string _name;

    public Worker(string name)
    {
        _name = name;
        _workerThread = new Thread(new ThreadStart(DoWork));
        _workerThread.Start();
    }
    private void DoWork()
    {
        while(true)
        {
            lock(_syncRoot)
            {
                Console.WriteLine(_name + "Doing Work");
            }
        }
    }
}

Answer 4

您正在做什么会有效，但为什么不成为_lockObject班Worker的{{1}}成员呢？它将达到同样的效果，但更加面向对象。

static

编辑：哎呀！我没有看到@Darin Dimitrov的回复，这与我在这里发布的内容相同。给你+1，Darin。

C＃可以多个类使用多个引用来锁定同一个对象吗？

4 个答案: