在C#中对ThreadPool使用lock语句

我有一个多线程程序（C#），其中我必须在线程之间共享全局静态变量，这些变量可能需要一些时间才能执行（使用WCF向另一个系统发送数据请求）。问题是，当在ThreadPool之外声明lock语句时，使用它似乎不能保证互斥。

static void Main(string[] args)
{
    public static int globalVar = 0;
    public object locker;
    System.Timers.Timer timer1 = new System.Timers.Timer(1000);
    timer1.Elapsed += new ElapsedEventHandler(onTimer1ElapsedEvent);
    timer1.Interval = 1000;
    timer1.Enabled = true;
    System.Timers.Timer timer2 = new System.Timers.Timer(500);
    timer2.Elapsed += new ElapsedEventHandler(onTimer2ElapsedEvent);
    timer2.Interval = 500;
    timer2.Enabled = true;
}
public void onTimer1ElapsedEvent(object source, ElapsedEventArgs e)
{
    lock (locker) {
        ThreadPool.QueueUserWorkItem(new WaitCallback(state => 
        {
            globalVar = 1;
            Console.WriteLine("Timer1 var = {0}", globalVar);
        }));
    } 
}
public void onTimer2ElapsedEvent(object source, ElapsedEventArgs e)
{
    lock (locker) {
        ThreadPool.QueueUserWorkItem(new WaitCallback(state => 
        {
            globalVar = 2;
            Thread.Sleep(2000);  // simulates a WCF request that may take time
            Console.WriteLine("Timer2 var = {0}", globalVar);
        }));
    } 
}

因此锁不起作用，程序可以打印：Timer2 var=1

将锁语句放入ThreadPool中似乎可以解决这个问题。

public void onTimer1ElapsedEvent(object source, ElapsedEventArgs e)
{
    ThreadPool.QueueUserWorkItem(new WaitCallback(state =>
    {
        lock (locker) {           
            globalVar = 1;
            Console.WriteLine("Timer1 var = {0}", globalVar);
        } 
    }));    
}
public void onTimer2ElapsedEvent(object source, ElapsedEventArgs e)
{
    ThreadPool.QueueUserWorkItem(new WaitCallback(state =>
    {
        lock (locker) {           
            globalVar = 2;
            Thread.Sleep(2000);  // simulates a WCF request that may take time
            Console.WriteLine("Timer2 var = {0}", globalVar);
        } 
    }));    
}

然而，我不知道这两种方法之间的区别，以及为什么它不会产生相同的行为。

此外，第二种方法解决了互斥问题，但timer1线程将始终等待timer2完成他的锁语句（这需要时间），因此多线程概念在我的程序中不再适用。我想知道让多线程与使用共享变量并行工作的最佳解决方案是什么？

您不需要锁来更新这样的变量。例如，您可以替换此：

lock (locker)
{
    globalVar = 1;
    Console.WriteLine("Timer1 var = {0}", globalVar);
}

带有：

int val = 1;
globalVar = val;
Console.WriteLine("Timer1 var = {0}", val);

对基元类型的写入保证是原子的，因此不需要在此处锁定。

现在，如果你想增加一个值，你可以写：

int val = Interlocked.Increment(ref globalVar);

您还可以添加：

int val = Interlocked.Add(ref globalVar, 100);

再说一遍，这些不需要锁。

查看Interlocked类。

在第一个场景中，您锁定的只是ThreadPool上的一个新的WaitCallback。将ThreadPool想象成一行：您所做的只是锁定其他人的队列（具有讽刺意味的是，这实际上是双重工作，因为ThreadPool本身锁定了它维护的内部队列）。ThreadPool随后执行的代码在不同的线程上，发生在不同的时间，与该锁无关。

在第二个场景中，锁实际上是ThreadPool线程正在执行的代码中的，这就是为什么您看到了预期的锁定语义。

不过，总的来说，如果可以避免的话，我建议不要锁定ThreadPool线程。ThreadPool应该（理想情况下）用于快速运行的任务。这取决于共享状态的性质和用途，以及您试图实现的目标，但通常情况下，我会尽可能选择使用Tasks和/或PLINQ。

更短、更明智的解决方案是不使用（另一个）额外的线程来执行Timer。System.Timers.Timer已经分配了一个池线程。

public void onTimer1ElapsedEvent(object source, ElapsedEventArgs e)
{
    lock (locker) {
            globalVar = 1;
            Console.WriteLine("Timer1 var = {0}", globalVar);
    } 
}
public void onTimer2ElapsedEvent(object source, ElapsedEventArgs e)
{
    lock (locker) {
            globalVar = 2;
            Thread.Sleep(2000);  // simulates a WCF request that may take time
            Console.WriteLine("Timer2 var = {0}", globalVar);
    } 
}

您的困惑来自于诸如"将锁语句放入ThreadPool"之类的公式。

您将锁语句放入方法中，以控制它们运行的线程。

相关内容

最新更新

热门标签：