C# 多线程

Question

好的。我想让两个线程运行。当前代码：

    public void foo()
    {      
            lock(this)
            {
                while (stopThreads == false)
                {
                   foreach (var acc in myList)
                   {
                     // process some stuff
                   }
                 }
             }
     }

    public void bar()
    {      
            lock(this)
            {
                while (stopThreads == false)
                {
                   foreach (var acc in myList)
                   {
                     // process some stuff
                   }
                 }
             }
     }

两者都访问同一个列表，问题是第一个线程“foo”没有释放我猜的锁；因为“bar”仅在“foo”完成后才开始。谢谢

Answer 1

是的，这就是锁的设计原理。

lock 关键字通过获取给定对象的互斥锁、执行语句，然后释放锁来将语句块标记为临界区。

互斥是指任一时刻最多只能有一个线程持有锁。

锁定这一点是一个坏主意，不鼓励这样做。您应该创建一个私有对象并锁定它。为了解决您的问题，您可以锁定两个不同的对象。

private object lockObject1 = new object();
private object lockObject2 = new object();

public void foo()
{      
    lock (lockObject1)
    {
         // ...
    }
}

public void bar()
{      
    lock (lockObject2)
    {
         // ...
    }
}

或者，您可以重复使用相同的锁，但将其移到循环内，以便每个循环都有机会继续进行：

while (stopThreads == false)
{
   foreach (var acc in myList)
   {
       lock (lockObject)
       {
           // process some stuff
       }
   }
}

但是，我建议您花一些时间来了解正在发生的事情，而不是重新排序代码行，直到它看起来可以工作在你的机器上。编写正确的多线程代码很困难。

为了停止线程，我推荐这篇文章：

• 优雅地关闭工作线程

Answer 2

由于您并不是真正在问问题，因此我建议您应该阅读有关线程如何工作的教程。可以此处找到 .Net 特定指南。它的主题包括“入门”、“基本同步”、“使用线程”、“高级线程”和“并行编程”。

另外，你还锁定了“这个”。 Msdn 说：

一般来说，避免锁定公共
类型或超出代码范围的实例
控制。常见的构造lock
(this)、lock (typeof (MyType)) 和
lock ("myLock") 违反了这一点
指导方针：

• lock (this) 是一个问题，如果
  实例可以公开访问。

• lock (typeof (MyType)) 是一个问题，如果
  MyType 可公开访问。

• lock(“myLock”) 是一个问题，因为
  进程中使用的任何其他代码
  相同的字符串，将共享相同的
  锁。

最佳实践是定义一个私有的
要锁定的对象，或私有静态
对象变量保护数据公共
到所有实例。

Answer 3

您遇到的问题是您使用的锁非常粗糙。 Foo 和 Bad 基本上不会同时工作，因为无论谁先启动，都会在整个工作周期中停止另一个。

不过，它应该仅在将内容从列表中删除时才锁定。根据定义，Foreach 在这里不起作用。您必须建立第二个列表，并让每个线程删除顶部的项目（同时锁定），然后对其进行处理。

基本上：

• Foreach 不起作用，因为两个线程都将运行完成列表
• 其次，锁必须是细粒度的，因为它们仅在需要时才锁定。

在你的情况下，你锁定的 foo 只会在 foo 完成时被释放。