.net中线程同步的典型场景和问题剖析
编程学习 2021-07-04 22:40www.dzhlxh.cn编程入门
在使用多线程进行编程时，有一些经典的线程同步问题，对于这些问题，.net提供了多种不同的类来解决
在使用多线程进行编程时，有一些经典的线程同步问题，对于这些问题，.net提供了多种不同的类来解决。除了要考虑场景本身，一个重要的问题是，这些线程是否在同一个应用程序域中运行。如果线程都在同一应用程序域中运行，则可以使用一些所谓“轻量”级的同步类，否则要使用另一些类，而这些类都是对操作系统所提供的同步原语的包装，相对来说更消耗资源。我在这儿介绍一些典型的应用场景和相关的问题。
多线程争用独占资源
常常有一些资源线程独占的，如果有多个线程同时需要访问这要的资源，就形成了一个争用问题。这类资源有“文件”，“打印机”，“串口”，以及所有非线程安全的类对象（绝大部分类库中的类都是）。典型的代码：
var objLock = new Object();
var thread1 = new Thread(() =>
{
lock (objLock)
{
AccessResource();
}
});
var thread2 = new Thread(() =>
{
lock (objLock)
{
AccessResource();
}
});
上面代码中，lock关键字实际上Monitor类的一个语法糖。任意一个对象(非值类型)上都有一个锁区域，Monitor.Enter方法会尝试锁定该区域，如果锁定成功，线程就拥有该对象，反子，线程将被挂起。对于objLock对象，有以下点需要注意:
不要锁定this
不要锁定Type
不要锁定字符串
不要锁定值类型的对象
对于相同的类，通常都会有很多不同的实例，这样的话，有可能会锁定到多个不同的对象上，从而使锁失效。不要锁定Type的原因有两点，一是生成Type类对象相对比较慢比较占资源，二是Type类型通常是公共的，这样有可能会在程序的多个不同地方会锁定，这实际上是个工程问题，主要是为了防止引入BUG。不要锁定string类，是因数，所有字面值相同的字符串，实际上是共享同一个对象的，所以和Type一样，也可能会无意间被别的代码锁定，这样的Bug将难以排除。不要锁定值类型，因为值类型本身是不可锁定的，为了可以锁定，编译器值将它装箱,而每次装箱实际上都会生成一个不同的对象实例，这样锁定也就没有任何效果了。
上面的代码有效的原因是所有线程都在同一个应用程序中，也就是不涉及进程间的资源争用。如果是多进程间的资源争用，可以使用Mutex类。Mutex类有两种不同用法，匿名互斥体和命名互斥体，命名的互斥体是在整个操作系统范围内共用的，所以可以用于进程间同步。
var mutex = new Mutex(false, "name");
var thread1 = new Thread(() =>
{
try
{
mutex.WaitOne();
AccessResource();
}
finally
{
mutex.ReleaseMutex();
}
});
var thread2 = new Thread(() =>
{
try
{
mutex.WaitOne();
AccessResource();
}
finally
{
mutex.ReleaseMutex();
}
});
需要注意的是，在线程结束时,必须释放互斥体。一对一的生产者/消费者模型在这种模型中，有一个生产者线程在产生需要处理的数据，同时有一个消费者线程在处理数据，通常来说，数据存放在一个缓存中。在种情况下，生产者每产生一个数据，就将它放入缓存中，并设置信号量(WaitHandle)，以通知消费者线程去处理。消费者不断的处理数据，如果发现所有数据都已经处理完毕，则进入阻塞状态，以等待生产者线程产生数据。信号量有两种，一种是AutoResetEvent,另一种是ManualResetEvent。前者的特点是每次设置一个信号后，将唤醒一个阻塞的线程，然后马上将信号量未设置状态。而后者的状态，则完全由程序控制，可能一次唤醒多个线程，也可能未唤醒作何一个线程。这种模型的例子代码。
using System;
using System.Collections.Generic;
using System.Threading;
namespace ThreadCancle
{
public class ProducerConsumer2
{
public static void Main()
{
var autoResetEvent = new AutoResetEvent(false);
var queue = new Queue<int>();
var producterThread = new Thread(() =>
{
var rand = new Random();
while (true)
{
var value = rand.Next(100);
lock (queue)
{
queue.Enqueue(value);
}
Thread.Sleep(rand.Next(400, 1200));
Console.WriteLine("产生了数据{0}。", value);
autoResetEvent.Set();
}
});
var consumerThread = new Thread(() =>
{
while (true)
{
autoResetEvent.WaitOne();
int value = 0;
bool hasValue = true;
while (hasValue)
{
lock (queue)
{
hasValue = (queue.Count > 0);
if (hasValue)
{
value = queue.Dequeue();
}
}
Thread.Sleep(800);
Console.WriteLine("处理了数据{0}。", value);
}
}
});
producterThread.Start();
consumerThread.Start();
Console.ReadLine();
}
}
}
在上面的例子中，生产者间隔0.4-1.2秒产生一个需要处理的数据，而消费者的处理能力是每0.8秒处理一个数据。生产者不断的产生数据，并将它放入queue中，然后唤醒消费者线程。消费者线程将queue中所有的数据处理完成后进入阻塞状态。需要注意的是,消费者线程和生产者线程会同时对queue对象进行访问，所有每次访问它们的时候必须锁定。执行锁定的时候必须遵循最少占用时间原则，一旦使用完毕应当立即释放锁定。
多线程争用独占资源
常常有一些资源线程独占的，如果有多个线程同时需要访问这要的资源，就形成了一个争用问题。这类资源有“文件”，“打印机”，“串口”，以及所有非线程安全的类对象（绝大部分类库中的类都是）。典型的代码：
代码如下:
var objLock = new Object();
var thread1 = new Thread(() =>
{
lock (objLock)
{
AccessResource();
}
});
var thread2 = new Thread(() =>
{
lock (objLock)
{
AccessResource();
}
});
上面代码中，lock关键字实际上Monitor类的一个语法糖。任意一个对象(非值类型)上都有一个锁区域，Monitor.Enter方法会尝试锁定该区域，如果锁定成功，线程就拥有该对象，反子，线程将被挂起。对于objLock对象，有以下点需要注意:
不要锁定this
不要锁定Type
不要锁定字符串
不要锁定值类型的对象
对于相同的类，通常都会有很多不同的实例，这样的话，有可能会锁定到多个不同的对象上，从而使锁失效。不要锁定Type的原因有两点，一是生成Type类对象相对比较慢比较占资源，二是Type类型通常是公共的，这样有可能会在程序的多个不同地方会锁定，这实际上是个工程问题，主要是为了防止引入BUG。不要锁定string类，是因数，所有字面值相同的字符串，实际上是共享同一个对象的，所以和Type一样，也可能会无意间被别的代码锁定，这样的Bug将难以排除。不要锁定值类型，因为值类型本身是不可锁定的，为了可以锁定，编译器值将它装箱,而每次装箱实际上都会生成一个不同的对象实例，这样锁定也就没有任何效果了。
上面的代码有效的原因是所有线程都在同一个应用程序中，也就是不涉及进程间的资源争用。如果是多进程间的资源争用，可以使用Mutex类。Mutex类有两种不同用法，匿名互斥体和命名互斥体，命名的互斥体是在整个操作系统范围内共用的，所以可以用于进程间同步。
代码如下:
var mutex = new Mutex(false, "name");
var thread1 = new Thread(() =>
{
try
{
mutex.WaitOne();
AccessResource();
}
finally
{
mutex.ReleaseMutex();
}
});
var thread2 = new Thread(() =>
{
try
{
mutex.WaitOne();
AccessResource();
}
finally
{
mutex.ReleaseMutex();
}
});
需要注意的是，在线程结束时,必须释放互斥体。一对一的生产者/消费者模型在这种模型中，有一个生产者线程在产生需要处理的数据，同时有一个消费者线程在处理数据，通常来说，数据存放在一个缓存中。在种情况下，生产者每产生一个数据，就将它放入缓存中，并设置信号量(WaitHandle)，以通知消费者线程去处理。消费者不断的处理数据，如果发现所有数据都已经处理完毕，则进入阻塞状态，以等待生产者线程产生数据。信号量有两种，一种是AutoResetEvent,另一种是ManualResetEvent。前者的特点是每次设置一个信号后，将唤醒一个阻塞的线程，然后马上将信号量未设置状态。而后者的状态，则完全由程序控制，可能一次唤醒多个线程，也可能未唤醒作何一个线程。这种模型的例子代码。
代码如下:
using System;
using System.Collections.Generic;
using System.Threading;
namespace ThreadCancle
{
public class ProducerConsumer2
{
public static void Main()
{
var autoResetEvent = new AutoResetEvent(false);
var queue = new Queue<int>();
var producterThread = new Thread(() =>
{
var rand = new Random();
while (true)
{
var value = rand.Next(100);
lock (queue)
{
queue.Enqueue(value);
}
Thread.Sleep(rand.Next(400, 1200));
Console.WriteLine("产生了数据{0}。", value);
autoResetEvent.Set();
}
});
var consumerThread = new Thread(() =>
{
while (true)
{
autoResetEvent.WaitOne();
int value = 0;
bool hasValue = true;
while (hasValue)
{
lock (queue)
{
hasValue = (queue.Count > 0);
if (hasValue)
{
value = queue.Dequeue();
}
}
Thread.Sleep(800);
Console.WriteLine("处理了数据{0}。", value);
}
}
});
producterThread.Start();
consumerThread.Start();
Console.ReadLine();
}
}
}
在上面的例子中，生产者间隔0.4-1.2秒产生一个需要处理的数据，而消费者的处理能力是每0.8秒处理一个数据。生产者不断的产生数据，并将它放入queue中，然后唤醒消费者线程。消费者线程将queue中所有的数据处理完成后进入阻塞状态。需要注意的是,消费者线程和生产者线程会同时对queue对象进行访问，所有每次访问它们的时候必须锁定。执行锁定的时候必须遵循最少占用时间原则，一旦使用完毕应当立即释放锁定。