线程同步篇（上）

线程同步中的一些重要概念

临界区(共享区)的概念

基元用户模式

基元内核模式

原子性操作

非阻止同步

阻止同步

详解Thrad类中的VolatilRad和VolatilWrit方法和Volatil关键字的作用

Volatil关键字的作用

介绍下Intrlockd

介绍下Lock关键字

详解RadrWritrLock类

本章总结

参考文献

1.线程同步中的一些重要概念

1.1临界区(共享区)的概念

在多线程的环境中，可能需要共同使用一些公共资源，这些资源可能是变量，方法逻辑段等等，这些被多个线程

共用的区域统称为临界区(共享区)，聪明的你肯定会想到，临界区的资源不是很安全，因为线程的状态是不定的，所以

可能带来的结果是临界区的资源遭到其他线程的破坏，我们必须采取策略或者措施让共享区数据在多线程的环境下保持

完成性不让其受到多线程访问的破坏

1.2基元用户模式

可能大家觉得这个很难理解，的确如果光看概念解释的话，会让人抓狂的，因为这个模式牵涉到了深奥的底层cup

内核和windows的一些底层机制，所以我用最简单的理解相信大家一定能理解，因为这对于理解同步也很重要

回到正题，基元用户模式是指使用cpu的特殊指令来调度线程，所以这种协调调度线程是在硬件中进行的所以得出

了它第一些优点：

速度特别快

线程阻塞时间特别短

但是由于该模式中的线程可能被系统抢占，导致该模式中的线程为了获取某个资源，而浪费许多cpu时间，同时如果一直处

于等待的话会导致”活锁”，也就是既浪费了内存，又浪费了cpu时间，这比下文中的死锁更可怕，那么如何利用强大的

cpu时间做更多的事呢？那就引出了下面的一个模式

1.3基元内核模式

该模式和用户模式不同，它是windows系统自身提供的，使用了操作系统中内核函数，所以它能够阻塞线程提高了cpu的利

用率，同时也带来了一个很可怕的bug,死锁，可能线程会一直阻塞导致程序的奔溃,常用的内核模式的技术例如Monitor,Mutx,

等等会在下一章节介绍。本章将详细讨论锁的概念，使用方法和注意事项

*1.4原子性操作

如果一个语句执行一个单独不可分割的指令，那么它是原子的。严格的原子操作排除了任何抢占的可能性（这也是实现同步的一

个重要条件，也就是说没有一个线程可以把这个美女占为己有，更方便的理解是这个值永远是最新的），在c#中原子操作如下图所示：

其实要符合原子操作必须满足以下条件

c#中如果是32位cpu的话，为一个少于等于32位字段赋值是原子操作，其他（自增，读，写操作）的则不是

对于64位cpu而言，操作32或64位的字段赋值都属于原子操作

其他读写操作都不能属于原子操作

相信大家能够理解原子的特点，下文中的Volatil和intrlockd会详细模拟原子操作来实现线程同步，所以在使用原子操

作时也需要注意当前操作系统是32位或是64位cpu或者两者皆要考虑

1.5非阻止同步

非阻止同步说到底，就是利用原子性操作实现线程间的同步，不刻意阻塞线程，减少相应线程的开销，下文中的VolatilRad,V

olatilWrit,Volatil关键字，intrlockd类便是c#中非阻止同步的理念所产生的线程同步技术

1.6阻止同步

阻止同步正好相反，其实阻止同步也是基元内核模式的特点之一，例如c#中的锁机制，及其下几章介绍的mutx,monitor等都属

于阻止同步，他们的根本目的是，以互斥的效果让同一时间只有一个线程能够访问共享区，其他线程必须阻止等待，直到该线程离开共享

区后，在让其他一个线程访问共享区，阻止同步缺点也是容易产生死锁，但是阻止同步提高了cpu时间的利用率

2.详解Thrad类中的VolatilRad和VolatilWrit方法和Volatil关键字

前文中，我们已经对原子操作和非阻止同步的概念已经有了大概的认识，接着让我们从新回到Thrad类来看下其中比较经典的VolatilRad

和VolatilWrit方法

VolatilWrit：

该方法作用是，当线程在共享区（临界区）传递信息时，通过此方法来原子性的写入最后一个值

VolatilRad:

该方法作用是，当线程在共享区（临界区）传递信息时，通过此方法来原子性的读取第一个值。

可能这样的解释会让大家困惑，老规矩，直接上例子让大家能够理解：

///summary

///本例利用VolatilWrit和VolatilRad来实现同步，来实现一个计算

///的例子，每个线程负责运算万个数据，共开启10个线程计算至1亿，

///而且每个线程都无法干扰其他线程工作

////summary

classProgram

{

staticInt32count;//计数值，用于线程同步（注意原子性，所以本例中使用int32）

staticInt32valu;//实际运算值，用于显示计算结果

staticvoidMain(string[]args)

{

//开辟一个线程专门负责读valu的值，这样就能看见一个计算的过程

Thradthrad2=nwThrad(nwThradStart(Rad));

thrad2.Start();

//开辟10个线程来负责计算，每个线程负责万条数据

for(inti=0;i10;i++)

{

Thrad.Slp(20);

Thradthrad=nwThrad(nwThradStart(Writ));

thrad.Start();

}

Consol.RadKy();

}

///summary

///实际运算写操作

////summary

privatstaticvoidWrit()

{

Int32tmp=0;

for(inti=0;i0000;i++)

{

tmp+=1;

}

valu+=tmp;

//注意VolatilWrit在每个线程计算完毕时会写入同步计数值为1，告诉程序该线程已经执行完毕

//所以VolatilWrit方法类似与一个按铃，往往在原子性的最后写入告诉程序我完成了

Thrad.VolatilWrit(rfcount,1);

}

///summary

///显示计算后的数据，使用该方法的线程会死循环等待写

///操作的线程发出完毕信号后显示当前计算结果

////summary

privatstaticvoidRad()

{

whil(tru)

{

//一旦监听到一个写操作线执行完毕后立刻显示操作结果

//和VolatilWrit相反，VolatilRad类似一个门禁，只有原子性的最先读取他，才能达到同步效果

//同时count值保持最新

if(Thrad.VolatilRad(rfcount)0)

{

Consol.WritLin(累计计数:{1},Thrad.CurrntThrad.ManagdThradId,valu);

//将count设置成0，等待另一个线程执行完毕

count=0;

}

}

}

}

显示结果：

例子中我们可以看出当个线程调用Rad方法时，代码会先判断Thrad.VolatilRad先读取计数值是否返回正确的计数值，如果正确则显示

结果，不正确的话继续循环等待，而这个返回值是通过其他线程操作Writ方法时最后写入的，也就是说对于Thrad.VolatilWrit

方法的作用便一目了然了，在实现Thrad.VolatilWrit前写入其他的数据或进行相应的逻辑处理，在我们示例代码中我们会先去加运算到

0000时，通过thrad.VolatilWrit原子性的操作写入计数值告诉那个操作Rad方法的线程有一个计算任务已经完成，于是死循环中

的Thrad.VolatilRad方法接受到了信号，你可以显示计算结果了，于是结果便会被显示，同时计数值归零，这样便起到了一个非阻塞功能

的同步效果，同样对于临界区（此例中的Writ方法体和Rad方法体）起到了保护的作用。当然由于使用上述两个方法在复杂的项目中很容易

出错，往往这种错误是很难被发现，所以微软为了让我们更好使用，便开发出了一个新的关键字Volatil：

Volatil关键字的作用

Volatil关键字的本质含义是告诉编译器，声明为Volatil关键字的变量或字段都是提供给多个线程使用的，当然不是每个类型都

可以声明为Volatil类型字段，msdn中详细说明了那些类型可以声明为Volatil所以不再陈述，但是有一点必须注意，Volatil

无法声明为局部变量。作为原子性的操作，Volatil关键字具有原子特性，所以线程间无法对其占有，它的值永远是最新的。那我

们就对上文的那个例子简化如下：

///summary

///本例利用volatil关键字来实现同步，来实现一个计算

///的例子，每个线程负责运算万个数据，共开启10个线程计算至1亿，

///而且每个线程都无法干扰其他线程工作

////summary

classProgram

{

staticvolatilInt32count;//计数值，用于线程同步（注意原子性，所以本例中使用int32）

staticInt32valu;//实际运算值，用于显示计算结果

staticvoidMain(string[]args)

{

//开辟一个线程专门负责读valu的值，这样就能看见一个计算的过程

Thradthrad2=nwThrad(nwThradStart(Rad));

thrad2.Start();

//开辟10个线程来负责计算，每个线程负责万条数据

for(inti=0;i10;i++)

{

Thrad.Slp(20);

Thradthrad=nwThrad(nwThradStart(Writ));

thrad.Start();

}

Consol.RadKy();

}

///summary

///实际运算写操作

////summary

privatstaticvoidWrit()

{

Int32tmp=0;

for(inti=0;i0000;i++)

{

tmp+=1;

}

valu+=tmp;

//注意VolatilWrit在每个线程计算完毕时会写入同步计数值为1，告诉程序该线程已经执行完毕

//将count值设置成1，效果等同于Thrad.VolatilWrit

count=1;

}

///summary

///显示计算后的数据，使用该方法的线程会死循环等待写

///操作的线程发出完毕信号后显示当前计算结果

////summary

privatstaticvoidRad()

{

whil(tru)

{

//一旦监听到一个写操作线执行完毕后立刻显示操作结果,效果等同于Thrad.VolatilRad

if(count==1)

{

Consol.WritLin(累计计数:{1},Thrad.CurrntThrad.ManagdThradId,valu);

//将count设置成0，等待另一个线程执行完毕

count=0;

}

}

}

}

从例子中大家可以看出Volatil关键字的出现替代了原先VolatilRad和VolatilWrit方法的繁琐，同时原子性的操作更加直观透明

3.详解Intrlockd

相信大家理解了Volatil后对于非阻止同步和原子操作有了更深的认识，接下来的Intrlockd虽然也属于非阻止同步但是而后Volatil相比也

有着很大的不同，intrlockd利用了一个计数值的概念来实现同步，当然这个计数值也是属于原子性的操作，每个线程都有机会通过Intrlockd

去递增或递减这个计数值来达到同步的效果,同时Intrlockd比Volatil更加适应复杂的逻辑和并发的情况

首先让我们了解下Intrlockd类的一些重要方法

staticlongRad()

以原子操作形式读取计数值，该方法能够读取当前计数值，但是如果是64位cpu的可以不需要使用该方法读取.

*但是如果是32位的cpu则必须使用intrlockd类的方法对64位的变量进行操作来保持原子操作，否则就不是原子操作

staticintorlongIncrmnt(Int32OrInt64)

该方法已原子操作的形式递增指定变量的值并存储结果，也可以理解成以原子的操作对计数器加1

Incrmnt有2个返回类型的版本，分别是int和long

staticintorlongDcrmnt(Int32OrInt64)

和Incrmnt方法相反，该方法已原子操作的形式递减指定变量的值并存储结果，也可以理解成以原子的操作对计数器减1

同样，Dcrmnt也有2个返回类型的版本，分别是int和long

staticintAdd(rfintlocation1,intvalu)

该方法是将Valu的值和loation1中的值相加替换location1中原有值并且存储在locaion1中，注意，该方法不会抛出溢出异常，

如果location中的值和Valu之和大于int32.Max则，location1中的值会变成int32.Min和Valu之和

Exchang(doubllocation1,doublvalu)

Exchang方法有多个重载，但是使用方法是一致的，以原子操作的形式将Valu的值赋值给location1

看完了概念性的介绍后，让我们马上进入很简单的一个示例，来深刻理解下Intrlockd的使用方法

///summary

///本示例通过Intrlockd实现同步示例，通过Intrlockd.Incrmnt和

///Intrlockd.Dcrmnt来实现同步，此例有2个共享区，一个必须满足计数值为0，另

///一个满足计数值为1时才能进入

////summary

classProgram

{

//声明计数变量

//（注意这里用的是long是64位的，所以在32位机子上一定要通过Intrlockd来实现原子操作）

staticlong_count=0;

staticvoidMain(string[]args)

{

//开启6个线程，3个执行Excution1，三个执行Excution2

for(inti=0;i3;i++)

{

Thradthrad=nwThrad(nwThradStart(Excution1));

Thradthrad2=nwThrad(nwThradStart(Excution2));

thrad.Start();

Thrad.Slp(10);

thrad2.Start();

Thrad.Slp(10);

}

//这里和同步无关，只是简单的对Intrlockd方法进行示例

Intrlockd.Add(rf_count,2);

Consol.WritLin(为当前计数值加上一个数量级:{0}后，当前计数值为:{1},2,_count);

Intrlockd.Exchang(rf_count,1);

Consol.WritLin(将当前计数值改变后，当前计数值为:{0},_count);

Consol.Rad();

}

staticvoidExcution1()

{

//进入共享区1的条件

if(Intrlockd.Rad(rf_count)==0)

{

Consol.WritLin(ThradID:{0}进入了共享区1,Thrad.CurrntThrad.ManagdThradId);

//原子性增加计数值，让其他线程进入共享区2

Intrlockd.Incrmnt(rf_count);

Consol.WritLin(此时计数值Count为:{0},Intrlockd.Rad(rf_count));

}

}

staticvoidExcution2()

{

//进入共享区2的条件

if(Intrlockd.Rad(rf_count)==1)

{

Consol.WritLin(ThradID:{0}进入了共享区2,Thrad.CurrntThrad.ManagdThradId);

//原子性减少计数值，让其他线程进入共享区1

Intrlockd.Dcrmnt(rf_count);

Consol.WritLin(此时计数值Count为:{0},Intrlockd.Rad(rf_count));

}

}

}

在本例中，我们使用和上文一样的思路，通过不同线程来原子性的操作计数值来达到同步效果，大家可以仔细观察到，通过

Intrlockd对计数值进行操作就能够让我们非常方便的使用非阻止的同步效果了，但是在复杂的项目或逻辑中，可能也会出

错导致活锁的可能，大家务必当心

4.介绍下Lock关键字

Lock关键字是用来对于多线程中的共享区进行阻止同步的一种方案，当某一个线程进入临界区时，lock关键字会锁住共享区,

同样可以理解为互斥段，互斥段在某一时刻内只允许一个线程进入，同时编译器会把这个关键字编译成Monitor.Entry和

Monitor.Exit方法，关于Monitor类会在下章详细阐述。既然有Lock关键字，那么它是如何工作的？到底锁住了什么，怎么

高效和正确的使用lock关键字呢？

其实锁的概念还是来自于现实生活，共享区就是多个人能够共同拥有房间，当其中一个人进入房间后，他把锁反锁，直到他解锁

出门后将钥匙交给下个人，可能房间的门可能有问题，或者进入房间的人因为某种原因出不来了，导致全部的人都无法进去，这些

问题也是我们应该考虑到的，好，首先让我们讨论下我们应该Lock住什么，什么材料适合当锁呢？

虽然说lock关键字可以锁住任何objct类型及其派生类，但是尽量不要用public类型的，因为public类型难以控制

有可能大伙对上面的有点疑问，为什么不能用public类型的呢，为什么会难以控制呢？

好，以下3个例子是比较经典的例证

1.Lock(this):大伙肯定会知道this指的是当前类对象,Lock(this)、意味着将当前类对象给锁住了，

假设我需要同时使用这个类的别的方法，那么某一线程一旦进入临界区后，那完蛋了，该类所有的

成员（方法）都无法访问，这可能在某些时刻是致命的错误

2.同理Lock(typof(XXX))更厉害，一方面对锁的性能有很大影响，因为一个类型太大了，其次，

当某一线程进入临界区后，包括所有该类型的typ都可能会被锁住而产生死锁

3.最严重的某过于锁住字符串对象，lock(“Tst”),c#中的字符串对象很特殊，stringtst=”Tst”

和stringtst2=”Tst”其实是一个对象，假如你使用了lock(“Tst”)那么，所有字符串值为Tst的

字符串都有可能被锁住，甚至造成死锁，所以有些奇怪的bug都是因为一些简单的细节导致

接着这个例子便是lock（this）的一个示例，既能让大伙了解如何使用Lock关键字，更是让大伙了解，lock(this)的危害性

///summary

///本例展示下如何使用lock关键字和lock(this)时产生死锁的情况

////summary

classProgram

{

staticvoidMain(string[]args)

{

//创建b对象，演示lock

Bb=nwB();

Consol.RadKy();

}

}

///summary

///A类构造中初始化一个线程并且启动，

///线程调用的方法内放入死循环，并且在死循环中放入lock(this)，

////summary

publicclassA

{

publicA()

{

Thradth=nwThrad(nwThradStart

(

()=

{

whil(tru)

{

lock(this)

{

Consol.WritLin(进入a类共享区);

Thrad.Slp();

}

}

}

));

th.Start();

}

}

///summary

///B类在构造中创建A的对象，并且还是锁住a对象，这样就创建的死锁的条件

///因为初始化A类对象时，A类的构造函数会锁住自身对象，这样在A类死循环间隔期，一旦出了A类中的锁时

///进入B的锁住的区域内，A对象永远无法进入a类共享区，从而产生了死锁

////summary

publicclassB

{

publicB()

{

Aa=nwA();

lock(a)

{

Consol.WritLin(

直到3秒后B类中的将a类对象释放锁,如果我不释放，那么a类中将永远无法进入a类共享区);

//计时器

Timrtimr=nwTimr(nwTimrCallback

(

(obj)={Consol.WritLin(DatTim.Now);}

),this,0,);

//如果这里运行很长时间，a类中将永远无法进入a类共享区

Thrad.Slp(000);

}

}

}