C#线程学习笔记四：线程同步
本笔记摘抄自：https://www.cnblogs.com/zhili/archive/2012/07/21/threadssynchronous.html，记录一下学习过程以备后续查用。
一、线程同步概述
创建多线程来实现让我们能够更好地响应应用程序，然而当我们创建了多个线程时，就存在多个线程同时访问一个共享资源的情况。此时，我们就需要用到线程同步。线程同
步可以防止数据（共享资源）的损坏。
一般来说，设计应用程序应尽量避免使用线程同步， 因为线程同步会产生一些问题：
1.1、它的使用比较繁琐。我们需要用额外的代码，把多个线程同时访问的数据包围起来，并获取和释放一个线程同步锁。如果有一个代码块忘记获取锁，就有可能造成数据损坏。
1.2、使用线程同步会影响性能。
1.2.1、获取和释放一个锁是需要时间的，我们在决定哪个线程先获取锁的时候，cpu要进行协调，这些额外的工作就会对性能造成影响。
1.2.2、线程同步一次只允许一个线程访问资源，这样就会阻塞线程，而阻塞线程会造成更多的线程被创建。这样cpu就有可能要调度更多的线程，从而对性能造成影响。
二、线程同步使用
2.1 使用锁对性能的影响
1.2.1描述过使用锁会对性能产生影响，下面通过比较使用锁和不使用锁消耗的时间来说明这点：
class program
{
static void main(string[] args)
{
#region 线程同步：使用与不使用锁的耗时对比
int x = 0;
//迭代500万次
const int iterationnumber = 5000000;
//不使用锁
stopwatch sw = stopwatch.startnew();
for (int i = 0; i < iterationnumber; i++)
{
x++;
}
console.writeline("total time consuming is:{0}ms.", sw.elapsedmilliseconds);
sw.restart();
//使用锁
for (int i = 0; i < iterationnumber; i++)
{
interlocked.increment(ref x);
}
console.writeline("total time consuming is:{0}ms.", sw.elapsedmilliseconds);
console.read();
#endregion
}
}
运行结果如下：
2.2 interlocked实现线程同步
interlocked为多个线程共享变量提供了原子操作，当我们在多线程中对一个整数进行递增操作时，就需要实现线程同步。
下面代码演示加锁与不加锁的区别：
不加锁：
class program
{
//共享资源
public static int number = 0;
static void main(string[] args)
{
#region 线程同步：使用interlocked实现线程同步
//不加锁
for (int i = 0; i < 10; i++)
{
thread thread = new thread(add);
thread.start();
}
console.read();
#endregion
}
/// <summary>
/// 递增不加锁
/// </summary>
public static void add()
{
thread.sleep(1000);
console.writeline("the current value of number is:{0}", ++number);
}
}
运行结果如下：
结果与预期可能不太一样。为了解决这样的问题，我们可以通过使用 interlocked.increment方法来实现自增操作。
实现原理：类似银行叫号，当有空号且号码是自己的，才能去办理相关的业务，否则继续等待。
加锁：
class program
{
//共享资源
public static int number = 0;
public static long signal = 0;
static void main(string[] args)
{
#region 线程同步：使用interlocked实现线程同步
//加锁
for (int i = 0; i < 10; i++)
{
thread thread = new thread(new parameterizedthreadstart(addwithinterlocked));
thread.start(i);
}
console.read();
#endregion
}
/// <summary>
/// 递增加interlocked锁
/// </summary>
public static void addwithinterlocked(object parameter)
{
while (interlocked.read(ref signal) != 0 || (int)parameter != number)
{
thread.sleep(100);
}
interlocked.increment(ref signal);
console.writeline("the current value of number is:{0}", ++number);
interlocked.decrement(ref signal);
}
}
运行结果如下：
2.3 monitor实现线程同步
对于上面那个情况，也可以通过monitor.enter和monitor.exit方法来实现线程同步。
c#中通过lock关键字来提供简化的语法(lock可以理解为monitor.enter和monitor.exit方法的语法糖)。
class program
{
//共享资源
public static int number = 0;
private static readonly object addlock = new object();
static void main(string[] args)
{
#region 线程同步：使用monitor实现线程同步
//非语法糖
for (int i = 0; i < 10; i++)
{
thread thread = new thread(addwithmonitor);
thread.start();
}
console.read();
//语法糖
//for (int i = 0; i < 10; i++)
//{
// thread thread = new thread(addwithlock);
// thread.start();
//}
//console.read();
#endregion
}
/// <summary>
/// 递增加monitor锁
/// </summary>
public static void addwithmonitor()
{
thread.sleep(100);
monitor.enter(addlock);
console.writeline("the current value of number is:{0}", ++number);
monitor.exit(addlock);
}
/// <summary>
/// 递增加lock锁
/// </summary>
public static void addwithlock()
{
thread.sleep(100);
lock (addlock)
{
console.writeline("the current value of number is:{0}", ++number);
}
}
}
运行结果如下：
接上面的addlock锁(以下描述为obj锁)，顺便学习一下monitor类的原理：
monitor在锁对象obj上会维持两个线程队列r和w以及一个引用t ：
(1)t是对当前获得了obj锁的线程的引用。
(2) r为就绪队列。
r队列上的线程，是已经准备好了去竞争获取obj锁的线程。
线程可通过调用monitor.enter(obj)或monitor.tryenter(obj)而直接进入r队列，可通过调用monitor.exit(obj)或monitor.wait(obj)释放其所获得的obj锁。
当obj锁被某个线程释放后，这个队列上的线程就会去竞争obj锁，而获得obj锁的线程将被t引用。
(3) w为等待队列。
w队列上的线程，是不会被os直接调度执行的线程。也就是说，等待队列上的线程不能去获得obj锁。
线程可通过调用monitor.wait(obj)而直接进入w队列，可通过调用monitor.pulse(obj)或monitor.pulseall(obj)将w队列中的第一个等待线程或所有等待线程移至r队列，
这时被移至r队列的这些线程就有机会被os直接调度执行，也就是可以去竞争obj锁。
(4)monitor的成员方法。
monitor.enter(obj)/monitor.tryenter(obj) ：线程会进入r队列以等待获取obj锁
monitor.exit(obj) ：线程释放obj锁（只有获取了obj锁的线程才能执行monitor.exit(obj)）
monitor.wait(obj)： 线程释放当前获得的obj锁，然后进入w队列并阻塞。
monitor.pulse(obj) ：将w队列中的第一个等待线程移至r队列中以使第一个线程有机会获取obj锁。
monitor.pulseall(obj)：将w队列中的所有等待线程移至r队列以使得这些线程有机会获得obj锁。
下面代码演示monitor.wait及monitor.pulse的使用：
class program
{
//共享资源
private static readonly object addlock = new object();
static void main(string[] args)
{
#region 线程同步：monitor.wait与monitor.pulse的使用
for (int i = 0; i < 10; i++)
{
thread thread = new thread(monitorwaitandpulse);
thread.start();
}
console.read();
#endregion
}
/// <summary>
/// monitor中的wait与pulse方法
/// </summary>
public static void monitorwaitandpulse()
{
//进入就绪队列等待获取锁资源
monitor.enter(addlock);
//进来打声招呼
console.writeline("{0}：我来了，临时要出去办一下事。", thread.currentthread.managedthreadid);
//唤醒等待队列中的第一个线程进入就绪队列
monitor.pulse(addlock);
//暂时释放锁资源进入等待队列
monitor.wait(addlock);
//出去办事
thread.sleep(1000);
//回来打声招呼
console.writeline("{0}：我回来了。", thread.currentthread.managedthreadid);
//释放锁资源
monitor.exit(addlock);
}
}
运行结果如下：
2.4 readerwriterlock实现线程同步
如果我们需要对一个共享资源执行多次读取时，用前面所讲的类实现的同步锁都仅允许一个线程进行访问，而其它线程将被阻塞。由于只是进行读取操作，其实是没有必要
堵塞其他的线程， 应该让它们并发的执行。
此时，可通过readerwriterlock类来实现并行读取。
class program
{
//创建对象
public static list<int> lists = new list<int>();
public static readerwriterlock readerwritelock = new readerwriterlock();
static void main(string[] args)
{
#region 线程同步：使用readerwriterlock实现线程同步
//创建一个线程读取数据
thread threadwrite = new thread(write);
threadwrite.start();
//创建10个线程读取数据
for (int i = 0; i < 10; i++)
{
thread threadread = new thread(read);
threadread.start();
}
console.read();
#endregion
}
/// <summary>
/// 写入方法
/// </summary>
public static void write()
{
//获取写入锁，以10毫秒为超时。
readerwritelock.acquirewriterlock(10);
random ran = new random();
int count = ran.next(1, 10);
lists.add(count);
console.writeline("write the data is:" + count);
//释放写入锁
readerwritelock.releasewriterlock();
}
/// <summary>
/// 读取方法
/// </summary>
public static void read()
{
thread.sleep(100);
//获取读取锁
readerwritelock.acquirereaderlock(10);
foreach (int list in lists)
{
//输出读取的数据
console.writeline(list);
}
// 释放读取锁
readerwritelock.releasereaderlock();
}
}