lock(MSDN)

lock 关键字可将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。此语句的形式如下：
lock(expression) statement_block
其中：
expression
指定要锁定的对象。expression 必须是引用类型。
通常，如果要保护实例变量，则 expression 为 this；如果要保护 static 变量（或者如果临界区出现在给定类的静态方法中），则 expression 为 typeOf (class)。
statement_block
临界区的语句。
备注
lock 确保当一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入一个锁定代码，则它将在释放该对象前一直等待（块）。
8.12 lock 语句对 lock 进行了讨论。
示例 1
下例显示的是在 C# 中使用线程的简单示例。
// statements_lock.cs
using System;
using System.Threading;

class ThreadTest
{
   public void runme()
   {
      Console.WriteLine("runme called");
   }

   public static void Main()
   {
      ThreadTest b = new ThreadTest();
      Thread t = new Thread(new ThreadStart(b.runme));
      t.Start();
   }
}
输出
runme called
示例 2
下例使用线程和 lock。只要 lock 语句存在，语句块就是临界区并且 balance 永远不会是负数。
// statements_lock2.cs
using System;
using System.Threading;

class Account
{
   int balance;

   Random r = new Random();

   public Account(int initial)
   {
      balance = initial;
   }

   int Withdraw(int amount)
   {

      // This condition will never be true unless the lock statement
      // is commented out:
      if (balance < 0)
      {
         throw new Exception("Negative Balance");
      }

      // Comment out the next line to see the effect of leaving out
      // the lock keyword:
      lock (this)
      {
         if (balance >= amount)
         {
            Console.WriteLine("Balance before Withdrawal :  " + balance);
            Console.WriteLine("Amount to Withdraw        : -" + amount);
            balance = balance - amount;
            Console.WriteLine("Balance after Withdrawal  :  " + balance);
            return amount;
         }
         else
         {
            return 0; // transaction rejected
         }
      }
   }

   public void DoTransactions()
   {
      for (int i = 0; i < 100; i++)
      {
         Withdraw(r.Next(1, 100));
      }
   }
}

class Test
{
   public static void Main()
   {
      Thread[] threads = new Thread[10];
      Account acc = new Account (1000);
      for (int i = 0; i < 10; i++)
      {
         Thread t = new Thread(new ThreadStart(acc.DoTransactions));
         threads[i] = t;
      }
      for (int i = 0; i < 10; i++)
      {
         threads[i].Start();
      }
   }
}

lock 语句用于获取某个给定对象的互斥锁，执行一个语句，然后释放该锁。
lock-statement:（lock 语句：）
lock   (   expression   )   embedded-statement（lock   (   表达式   )   嵌入语句）
lock 语句的表达式必须表示一个引用类型的值。永远不会为 lock 语句中的表达式执行隐式装箱转换（第 6.1.5 节），因此，如果该表达式表示的是一个值类型的值，则会导致一个编译时错误。
下列形式的 lock 语句
lock (x) ...
（其中 x 是一个引用类型的表达式）完全等效于
System.Threading.Monitor.Enter(x);
try {
   ...
}
finally {
   System.Threading.Monitor.Exit(x);
}
不同的只是：实际执行中 x 只计算一次。
当一个互斥锁已被占用时，在同一线程中执行的代码仍可以获取和释放该锁。但是，在其他线程中执行的代码在该锁被释放前是无法获得它的。
一个类的 System.Type 对象可以方便地用来当作关于该类的静态方法的互斥锁。例如：
class Cache
{
   public static void Add(object x) {
      lock (typeof(Cache)) {
         ...
      }
   }
   public static void Remove(object x) {
      lock (typeof(Cache)) {
         ...
      }
   }
}