c++线程同步

到目前为止，线程同步最为普遍的用途是确保多线程对共享资源的互斥访问。对于同步单个进程中的多个线程以实现互斥访问，win32
api中的critical_section结构以及与它相关的函数提供了最为快速和高效的途径，microsoft .net
framework并没有提供critical_section结构，但提供了一个类似的机制——该机制通过
system.threading.monitor类和syncblock得以实现。
在这个专栏里，我会解释.net
framework如何支持线程同步的这个普遍用途。另外，我还要解释syncblock和monitor被设计成现在这个样子的动机以及它们是如何工作
的。最后我还要解释为什么这个设计是糟糕的，以及如何用正确和安全的方式去使用该机制。

绝妙的主意

.net
framework采用了oop式的结构。这就意味着：开发者构造对象，然后调用类型的成员来操纵它。然而有时候这些对象也会被多个线程所操纵，因此，为
了确保对象的状态不被破坏，必须进行线程同步。在设计.net
framework时，microsoft的设计师们决定创造一个新的机制来让开发者们轻易地同步一个对象。
基本想法是这样的：堆
上的每个对象都关联着一个可以被用于线程同步的数据结构（非常类似于win32的critical_section）。然后，fcl（framework
class library，框架类库）再提供一些方法（method）——当你将对象的引用传递过去时——使用这个数据结构来同步线程。
如果将这个设计运用在win32下的非托管的c++类上，则该类看起来像这样：

图1
． a critical_section for every object

class sometype {
private:
// 为每个对象关联一个私有的critical_section字段
critical_section m_csobject;

public:
sometype() {
// 在构造函数中初始化critical_section字段
initializecriticalsection(&m_csobject);
}

~sometype() {
// 在析构函数中delete critical_section字段
deletecriticalsection(&m_csobject);
}

void somemethod() {
// 在该函数中，我们使用了对象的critical_section字段
// 来同步多个线程对该对象的访问
entercriticalsection(&m_csobject);
// 在这里可以执行线程安全的代码了...
leavecriticalsection(&m_csobject);
}

void anothermethod() {
// 在该函数中，我们使用了对象的critical_section字段
// 来同步多个线程对该对象的访问
entercriticalsection(&m_csobject);
// 在这里可以执行线程安全的代码了...
leavecriticalsection(&m_csobject);
}
};

本质上，.net
framework为每个对象关联一个类似critical_section的字段，并且负责对它进行初始化和删除。开发者要做的唯一一件事情是：在需要线程同步的方法中加入一些代码以进入（enter）和离开（leave）该字段。

实现绝妙的主意

现在，很明显，为堆上的每个对象都关联一个critical_section字段是一件很浪费的事情，特别是由于大多数对象从不需要线程安全的访问。因此，.net framework小组设计了一个更高效的途径来提供前面描述的功能。下面就来说说它是如何工作的：
当clr（公共语言运行时）初始化时，它分配一个syncblock的缓存区。一个syncblock就是一个可以根据需要关联到任何对象的内存块。syncblock具有与win32 critical_section相同的字段。
堆
上的每个对象在创建时都关联了两个额外的字段——第一个是methodtablepointer（方法表指针），包含了该类型的方法表的地址。基本上，这
个指针使你能够获取堆上的每个对象的类型信息。事实上，当你调用system.object的gettype方法时，该方法通过对象的
methodtablepointer字段来确定对象的类型。另一个额外的字段——称为syncblockindex——包含一个32位的有符号整数，在
syncblock缓存区中索引一个syncblock。
当一个对象被构造时，它的syncblockindex字段会被初始化为
一个负值——表示根本不指向任何syncblock。然后，当某个方法被调用以同步对该对象的访问时，clr在syncblock缓存区中寻找一个空闲的
syncblock，并且让该对象的syncblockindex字段指向它。换句话说，syncblock只在某个对象需要同步字段时才会被关联到该对
象。而当不再有任何线程对该对象进行同步访问时，该对象的syncblockindex字段就会被重置为一个负值，并且相应的syncblock也被释
放，以便在将来可以被重新关联到其它对象。
图 2. .net
中的线程同步

图2
是这个思想的具体表现形式。在该图的clr data structures
部分，你可以看到，系统所知道的每个类型都有一个对应的数据结构。你也可以看到syncblock结构的集合。在该图的managed heap
部
分你可以看到有三个对象（objecta,objectb,objectc）被创建了。每个对象的methodtablepointer字段都指向相应类
型的方法表。通过方法表，你可以获得每个对象的类型。所以，我们可以很容易的看到，objecta和objectb都是sometype类型的实例，而
objectc是anothertype类型的实例。
objecta的syncblockindex字段被设为0，这表示
syncblock
#0目前正被objecta使用。另一方面，objectb的syncblockindex被设为-1，表示并没有任何syncblock与它关联。最
后，objectc的syncblockindex为2，表明它正在使用syncblock #2。在本例中，syncblock
#1没有被使用，但是将来可能会与某个对象关联。
因此，从逻辑上说，堆上的每个对象都关联着一个syncblock——它可以被用于快速互斥的线程同步。然而，从物理上说，syncblock仅当
被需要时才会与某个对象关联，并且在对象不再需要它时从对象上脱离。这意味着内存的使用是有效率的。另外，如果有必要，syncblock缓存可以创建更多的syncblock，因此你不用担心它会由于同一时刻同步对象过多而被用尽。

使用monitor
来操纵syncblock

既然你已经理解了syncblock，就让我们来看看如何锁定一个对象。要锁定或解锁一个对象，你可以使用system.threading.monitor类。该类型的所有方法都是静态的。调用下面的方法可以锁定一个对象：

public static void enter(object obj);

当
你调用enter方法时，它首先检查指定的对象的syncblockindex是否为负值，如果是的，则该方法从syncblock缓存中找一个空闲的
syncblock并且将它的索引保存到对象的syncblockindex中。一旦对象上已经关联了syncblock，则enter方法就会检查对象
的syncblock，看看当前是否有另一个线程正拥有这个syncblock。如果当前没有任何进程拥有它，则当前调用enter的线程成为该对象的所
有者。另一方面，如果另一个线程已经拥有了该syncblock，则当前调用enter的线程会挂起，直到那个线程释放对syncblock的所有权。
如果你想写更具防御性的代码，则可以调用下面的tryenter方法之一：

public static boolean tryenter(object obj);

public static boolean tryenter(object obj,
int millisecondstimeout);

public static boolean tryenter(object obj,
timespan timeout);

第一个tryenter只是简单的检查调用它的线程能否获得对象的syncblock的所有权，如果成功则返回true。另外两个方法则允许你指定一个等待时间，表示你允许线程等待所有权多久。如果不能获得所有权，则三个方法都会返回false。
一旦获得了所有权，代码就可以安全地访问对象的字段了。访问完毕之后，线程还应该调用exit来释放syncblock：

public static void exit(object obj);

如
果线程并没有获得指定对象的syncblock的所有权，则调用exit会抛出一个synchronizationlockexception。同时还要
注意，线程可以递归式获取一个syncblock的所有权，每次成功的enter必须对应一个exit，这样最终syncblock才会被释放（这一点与
win32的critical_section是一样的——译者）。

synchronizing the microsoft way

现在让我们看看图3
的
示例代码，它展示了如何使用monitor的enter和exit方法来锁定和解锁一个对象。注意，lasttransaction属性
(property)的实现需要调用enter，exit以及一个临时变量dt。这是非常重要的，这样可以避免返回一个已经被破坏的值——如果一个线程调
用performtransaction时另一个线程在访问该属性就会发生这种情况。

用c#

的lock
语句来简化代码

因为这种“调用enter——访问受保护资源——调用exit”的模式是如此普遍，所以c#干脆提供了特殊的语法来简化这种代码。图4
的两段c#代码片断功能相同，但是后者更为简洁。使用c#的lock语句，你可以将transaction类充分简化。特别要注意图5
中所展示的改进后的lasttransaction属性，它不再需要临时变量了。
除
了能够简化代码外，lock语句还确保了monitor.exit一定会被调用，从而即使在try块中产生了一个异常，syncblock也会被释放。你
应该始终将异常处理与同步机制结合起来使用，以确保锁被正确释放。然而，如果你使用c#的lock语句，则编译器会自动帮你生成正确的代码。另
外，visual basic .net也有一个类似于c#的lock语句的synclock语句，它们做同样的事情。

synchronizing static members the microsoft way

transaction
类示范了如何同步访问一个对象的实例字段。但是，如果你的类型定义了一些静态字段以及访问这些字段的静态函数又当如何呢？在这种情况下，堆上并没有该类型
的实例，因而也就没有可用的syncblock或者传递给monitor.enter和monitor.exit方法的对象引用。
事实上，包含某个类型的类型描述符的内存块是位于堆上的对象。图2
中
并没有表现出这一点，但是sometype的类型描述符和anothertype的类型描述符所占的内存块其实本身都是对象，并且同样也有
methodtablepointer字段和syncblockindex字段。这就意味着syncblock可以被关联到一个类型，并且类型对象
（type object，指“描述一个类型”的对象）的引用可以被传递给monitor的enter和exit方法。在图6
所示的transaction类中，所有的成员都改成了静态的，并且performtransaction方法和lasttransaction属性也作了改动以展示microsoft希望开发者如何同步对静态成员的访问。
在
performtransaction方法和lasttransaction属性中，你不再会看到this关键字，因为在静态成员中不能使用它。我将类型
的类型描述符对象的引用传给lock语句。这个引用是通过c#的typeof操作符得到的，typeof操作符返回指定对象的对象描述符的引用。在
visual basic .net中，gettype操作符具有同样的功能。

为什么绝妙的主意并不那么绝妙

如
你所见，使堆上的每个对象逻辑上关联一个用于同步的数据结构的主意听起来很不错。但是实际上这是一个糟糕的主意。听我解释原因。还记得在本文开头展示的非
托管的c++代码吗？如果由你来写，你会将critical_section字段的访问权限设为public吗？当然不会——那简直是荒谬的。将这个字段
设为public会允许程序中的任何代码操纵该critical_section结构，这样恶意代码很容易就能够将使用该类型的实例的任何线程死锁住。
呃...猜猜看发生了什么——syncblock正如一个public字段一样！任何一段代码在任何时候都可以将任何对象的引用传给monitor的enter和exit方法。事实上，任何类型描述符的引用也同样可以被传给monitor的方法。
图7
的
代码显示了这种情况是多么糟糕。这里，main方法中创建了一个app对象，然后锁定该对象，并在某个时刻发生一次垃圾收集（在这段代码中，强制一次垃圾
收集），当app的finalize方法被调用时，它也会试图锁定该对象，但是由于程序的主线程已经锁定了该对象，所以clr的finalize线程无法
锁定它。这就导致clr的finalize线程停止了——于是在当前进程（可能包含多个appdomain）中再也不会有其它对象可以被
finalize，也不再有其它可finalize的对象在堆上的内存会被回收。
幸运的是有一个解决方案，只不过那意味着你得抛开
microsoft的设计和建议。取而代之的是定义一个private的system.object字段作为你的类型的成员，构造它，然后将其引用传递给
c#的lock语句或visual basic .net的synclock语句。图8
展示了如何重写transaction类以便让用于同步的对象成为该类的私有成员。同样地，图9
展示了当transaction类的成员全为静态时如何去重写它。
看
起来，仅仅为了同步而构造一个system.object对象是比较怪异的。我感觉microsoft对monitor类的设计并不恰当。应该让你为每个
想要同步的类型（原文为type，疑为object）构造一个monitor类型的实例。这样，静态方法（monitor类的静态方法）就会成为不需要
system.object参数的实例方法。这将解决所有的问题，并且充分简化开发者的编程模型。
另外，如果你创建具有许多字段的
复杂类型，则在任何时候，你的方法和属性可能只需要锁定这些字段的一个子集。你始终可以通过将指定字段的引用传给lock或monitor.enter来
锁定它。当然，如果字段为私有（我始终建议如此），则我只会考虑这样做。如果你想要将几个字段一起锁定，那么你可以始终将其中的一个传给lock或
enter。或者，你还可以构造一个system.object对象——它的唯一意图就是用于锁定一集字段。lock
段（临界段）越细化，代码的性能和可测性就越好[1]
。
[1] 译注：作者的意思是，应该保持lock（临界）段的短小，换句话说，一个lock（临界）段应该执行尽量少的代码，这样才能保证其它线程在lock（临界）区上的等待时间尽量短，并且死锁的可能性也更小。

未装箱的（unboxed
）值类型实例

在结束这个专栏之前，我想要指出一个有关同步的bug，我第一次遇到它时花了好几个小时来跟踪。下面的代码片断示范了这个问题：

class anothertype {

// 一个 未装箱的（unboxed） boolean 值类型实例
private boolean flag = false;
public boolean flag {
set {
monitor.enter(flag); // 将flag装箱并锁定装箱后的对象

flag = value; // 而实际的值却未受保护
monitor.exit(flag); // 将flag装箱并试图unlock装箱后的对象

}
}
}

你可能会惊讶于在这段代码中并没有发生任何线程
同步

！原因是：flag是个未装箱的值类型实例，而并非一个引用类型。未装箱的值类型实例并没有methodtablepointer和syncblockindex这两个额外的字段。这就意味着一个未装箱的值类型实例不可能有一个与它关联的syncblock。
monitor
的enter和exit方法要求一个指向堆上的对象的引用。当c#，visual basic
.net和许多其它编译器看到一段代码试图将未装箱的值类型实例传给需要对象引用的方法时，它们会自动生成代码来将该值类型的实例装箱（box）。装箱后
的实例（位于堆上）将会拥有一个methodtablepointer和一个syncblockindex，因而可以被用于线程同步。然而，每调用这样的
函数一次就会进行一次新的装箱，即产生一个新的装箱后的实例，这个实例与以前装箱的实例都不相同，也就是说，我们每次lock和unlock的都是不同的
对象。
例如，在上面代码片断中，当flag属性的set方法被调用时，它调用了monitor的enter方法。enter需要一
个引用类型，因此flag被装箱，并且装箱后的对象的引用被传递给enter，该对象的syncblock现在归调用线程所有。如果另一个线程现在也要访
问这个属性，那么flag将会被再次装箱，产生一个新的对象，它拥有自己的syncblock。另外，对exit的调用也会导致一次装箱操作。
正如我前面所说，我花了好几个小时才发现问题所在。如果你想要同步对一个未装箱的值类型实例的访问，那么你必须分配一个system.object对象，并利用它来进行同步。图10
中的代码是正确的。
另
外，如果你使用c#
的lock语句来代替monitor.enter与monitor.exit，那么c#编译器会帮你避免意外地试图去lock一个值类
型。当你将一个未装箱的值类型实例传给lock语句时，c#编译器会报错。例如，如果你试图将一个boolean（c#中的bool）传给lock语句，
那么你将看到如下的错误：“error cs0185：'bool' is not a reference type as required by
the lock statement”。而在visual basic
.net中，如果你对synclock语句使用未装箱的值类型实例，编译器也会报错：“error bc30582: 'synclock'
operand cannot be of type 'boolean' because 'boolean' is not a
reference type”。

图 3. using enter and exit methods

class transaction {

// private field holding the time of
// the last transaction performed
private datetime timeoflasttransaction;

public void performtransaction() {
// lock this object
monitor.enter(this);

// perform the transaction...

// record time of the most recent transaction
timeoflasttransaction = datetime.now;

// unlock this object
monitor.exit(this);
}

// public read-only property returning
// the time of the last transaction
public datetime lasttransaction {
get {
// lock this object
monitor.enter(this);

// save the time of the last transaction
// in a temporary variable
datetime dt = timeoflasttransaction;

// unlock this object
monitor.exit(this);

// return the value in the temporary variable
return(dt);
}
}
}

图 4
. regular and simple lock and unlock

// regular function
public void somemethod() {
// lock the object
object otemp = this;
monitor.enter(otemp);
try {
// access the object
...
// unlock the object
}
finally {
monitor.exit(otemp);
}
// return
}

// simple function
public void somemethod() {
// lock the object
lock (this) {

// access the object
...
// unlock the object
}

// return
}

图 5
. transaction class

class transaction {

// private field holding the time of
// the last transaction performed
private datetime timeoflasttransaction;

public void performtransaction() {
lock (this) {
// perform the transaction...

// record time of the most recent transaction
timeoflasttransaction = datetime.now;
}
}

// public read-only property returning
// the time of the last transaction
public datetime lasttransaction {
get {
lock (this) {
// return the time of the last transaction
return timeoflasttransaction;
}
}
}
}

图 6
. new transaction class

class transaction {

// private field holding the time of
// the last transaction performed
private static datetime timeoflasttransaction;

public static void performtransaction() {
lock (typeof(transaction)) {
// perform the transaction...

// record time of the most recent transaction
timeoflasttransaction = datetime.now;
}
}

// public read-only property returning
// the time of the last transaction
public static datetime lasttransaction {
get {
lock (typeof(transaction)) {
// return the time of the last transaction
return timeoflasttransaction;
}
}
}
}

图 7
. threads
banging heads

using system;
using system.threading;

class app {
static void main() {
// construct an instance of the app object
app a = new app();

// this malicious code enters a lock on
// the object but never exits the lock
monitor.enter(a);

// for demonstration purposes, let's release the
// root to this object and force a garbage collection
a = null;
gc.collect();

// for demonstration purposes, wait until all finalize
// methods have completed their execution - deadlock!
gc.waitforpendingfinalizers();

// we never get to the line of code below!
console.writeline("leaving main");
}

// this is the app type's finalize method
~app() {
// for demonstration purposes, have the clr's
// finalizer thread attempt to lock the object.
// note: since the main thread owns the lock,
// the finalizer thread is deadlocked!
lock (this) {
// pretend to do something in here...
}
}
}

图 8
. transaction with private object

class transaction {

// private object field used
// purely for synchronization
private object objlock = new object();

// private field holding the time of
// the last transaction performed
private datetime timeoflasttransaction;

public void performtransaction() {
lock (objlock) {
// perform the transaction...

// record time of the most recent transaction
timeoflasttransaction = datetime.now;
}
}

// public read-only property returning
// the time of the last transaction
public datetime lasttransaction {
get {
lock (objlock) {
// return the time of the last transaction
return timeoflasttransaction;
}
}
}
}

图 9
. transaction with static members

class transaction {

// private, static object field
// used purely for synchronization
private static object objlock = new object();

// private field holding the time of
// the last transaction performed
private static datetime timeoflasttransaction;

public static void performtransaction() {
lock (objlock) {
// perform the transaction...

// record time of the most recent transaction
timeoflasttransaction = datetime.now;
}
}

// public read-only property returning
// the time of the last transaction
public static datetime lasttransaction {
get {
lock (objlock) {
// return the time of the last transaction
return timeoflasttransaction;
}
}
}
}

图 10
. now there's synchronization

class anothertype {

// an unboxed boolean value type
private boolean flag = false;

// a private object field used to
// synchronize access to the flag field
private
object flaglock = new object();

public boolean flag {
set {
monitor.enter(flaglock);
flag = value;
monitor.exit(flaglock);
}
}
}