线程同步（C# 编程指南）

 

以下各节描述了在多线程应用程序中可以用来同步资源访问的功能和类。

在应用程序中使用多个线程的一个好处是每个线程都可以异步执行。对于 Windows 应用程序，耗时的任务可以在后台执行，而使应用程序窗口和控件保持响应。对于服务器应用程序，多线程处理提供了用不同线程处理每个传入请求的能力。否则，在完全满足前一个请求之前，将无法处理每个新请求。

然而，线程的异步特性意味着必须协调对资源（如文件句柄、网络连接和内存）的访问。否则，两个或更多的线程可能在同一时间访问相同的资源，而每个线程都不知道其他线程的操作。结果将产生不可预知的数据损坏。

对于整数数据类型的简单操作，可以用 Interlocked 类的成员来实现线程同步。对于其他所有数据类型和非线程安全的资源，只有使用本主题中的结构才能安全地执行多线程处理。

有关多线程编程的背景信息，请参见：

• 使用线程处理（C# 编程指南）

• 托管线程处理基本知识

• 使用线程和线程处理

• 托管线程处理的最佳做法

lock 关键字

---

lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。

lock 语句以关键字 lock 开头，它有一个作为参数的对象，在该参数的后面还有一个一次只能由一个线程执行的代码块。例如：

VB

C#

C++

F#

JScript

 

复制

public void Function()

{

    System.Object lockThis = new System.Object();

    lock(lockThis)

    {

        // Access thread-sensitive resources.

    }

}

提供给 lock 关键字的参数必须为基于引用类型的对象，该对象用来定义锁的范围。在上例中，锁的范围限定为此函数，因为函数外不存在任何对该对象的引用。严格地说，提供给 lock 的对象只是用来唯一地标识由多个线程共享的资源，所以它可以是任意类实例。然而，实际上，此对象通常表示需要进行线程同步的资源。例如，如果一个容器对象将被多个线程使用，则可以将该容器传递给 lock，而 lock 后面的同步代码块将访问该容器。只要其他线程在访问该容器前先锁定该容器，则对该对象的访问将是安全同步的。

通常，最好避免锁定 public 类型或锁定不受应用程序控制的对象实例。例如，如果该实例可以被公开访问，则 lock(this) 可能会有问题，因为不受控制的代码也可能会锁定该对象。这可能导致死锁，即两个或更多个线程等待释放同一对象。出于同样的原因，锁定公共数据类型（相比于对象）也可能导致问题。锁定字符串尤其危险，因为字符串被公共语言运行库 (CLR)“暂留”。这意味着整个程序中任何给定字符串都只有一个实例，就是这同一个对象表示了所有运行的应用程序域的所有线程中的该文本。因此，只要在应用程序进程中的任何位置处具有相同内容的字符串上放置了锁，就将锁定应用程序中该字符串的所有实例。因此，最好锁定不会被暂留的私有或受保护成员。某些类提供专门用于锁定的成员。例如，Array 类型提供 SyncRoot。许多集合类型也提供 SyncRoot。

有关 lock 关键字的更多信息，请参见：

• lock 语句（C# 参考）

• 如何：对制造者线程和使用者线程进行同步（C# 编程指南）

监视器

---

与 lock 关键字类似，监视器防止多个线程同时执行代码块。Enter 方法允许一个且仅一个线程继续执行后面的语句；其他所有线程都将被阻止，直到执行语句的线程调用 Exit。这与使用 lock 关键字一样。事实上，lock 关键字就是用 Monitor 类来实现的。例如：

VB

C#

C++

F#

JScript

 

复制

lock(x)

{

    DoSomething();

}

这等效于：

VB

C#

C++

F#

JScript

 

复制

System.Object obj = (System.Object)x;

System.Threading.Monitor.Enter(obj);

try

{

    DoSomething();

}

finally

{

    System.Threading.Monitor.Exit(obj);

}

使用 lock 关键字通常比直接使用 Monitor 类更可取，一方面是因为 lock 更简洁，另一方面是因为 lock 确保了即使受保护的代码引发异常，也可以释放基础监视器。这是通过 finally 关键字来实现的，无论是否引发异常它都执行关联的代码块。

有关监视器的更多信息，请参见监视器同步技术示例。

同步事件和等待句柄

---

使用锁或监视器对于防止同时执行区分线程的代码块很有用，但是这些构造不允许一个线程向另一个线程传达事件。这需要“同步事件”，它是有两个状态（终止和非终止）的对象，可以用来激活和挂起线程。让线程等待非终止的同步事件可以将线程挂起，将事件状态更改为终止可以将线程激活。如果线程试图等待已经终止的事件，则线程将继续执行，而不会延迟。

同步事件有两种：AutoResetEvent 和 ManualResetEvent。它们之间唯一的不同在于，无论何时，只要 AutoResetEvent 激活线程，它的状态将自动从终止变为非终止。相反，ManualResetEvent 允许它的终止状态激活任意多个线程，只有当它的 Reset 方法被调用时才还原到非终止状态。

可以通过调用一种等待方法，如 WaitOne、WaitAny 或 WaitAll，让线程等待事件。System.Threading.WaitHandle.WaitOne 使线程一直等待，直到单个事件变为终止状态；System.Threading.WaitHandle.WaitAny 阻止线程，直到一个或多个指示的事件变为终止状态；System.Threading.WaitHandle.WaitAll 阻止线程，直到所有指示的事件都变为终止状态。当调用事件的 Set 方法时，事件将变为终止状态。

在下面的示例中，创建了一个线程，并由 Main 函数启动该线程。新线程使用 WaitOne 方法等待一个事件。在该事件被执行 Main 函数的主线程终止之前，该线程一直处于挂起状态。一旦该事件终止，辅助线程将返回。在本示例中，因为事件只用于一个线程的激活，所以使用 AutoResetEvent 或 ManualResetEvent 类都可以。

VB

C#

C++

F#

JScript

 

复制

using System;

using System.Threading;



class ThreadingExample

{

    static AutoResetEvent autoEvent;



    static void DoWork()

    {

        Console.WriteLine("   worker thread started, now waiting on event...");

        autoEvent.WaitOne();

        Console.WriteLine("   worker thread reactivated, now exiting...");

    }



    static void Main()

    {

        autoEvent = new AutoResetEvent(false);



        Console.WriteLine("main thread starting worker thread...");

        Thread t = new Thread(DoWork);

        t.Start();



        Console.WriteLine("main thrad sleeping for 1 second...");

        Thread.Sleep(1000);



        Console.WriteLine("main thread signaling worker thread...");

        autoEvent.Set();

    }

}

有关线程同步事件用法的更多示例，请参见：

• 监视器同步技术示例

• 读取器－编写器同步技术示例

• 线程池技术示例

• 等待同步技术示例

Mutex 对象

---

mutex 与监视器类似；它防止多个线程在某一时间同时执行某个代码块。事实上，名称“mutex”是术语“互相排斥 (mutually exclusive)”的简写形式。然而与监视器不同的是，mutex 可以用来使跨进程的线程同步。mutex 由 Mutex 类表示。

当用于进程间同步时，mutex 称为“命名 mutex”，因为它将用于另一个应用程序，因此它不能通过全局变量或静态变量共享。必须给它指定一个名称，才能使两个应用程序访问同一个 mutex 对象。

尽管 mutex 可以用于进程内的线程同步，但是使用 Monitor 通常更为可取，因为监视器是专门为 .NET Framework 而设计的，因而它可以更好地利用资源。相比之下，Mutex 类是 Win32 构造的包装。尽管 mutex 比监视器更为强大，但是相对于 Monitor 类，它所需要的互操作转换更消耗计算资源。有关 mutex 的用法示例，请参见 Mutex。

相关章节

---

• 如何：创建和终止线程（C# 编程指南）

• 如何：使用线程池（C# 编程指南）

• 如何：通过使用 Visual C# .NET 在多线程处理环境中同步对共享资源的访问

• 如何：使用 Visual C# .NET 创建线程

• 如何：使用 Visual C# .NET 向线程池提交工作项

• 如何：通过使用 Visual C# .NET 在多线程处理环境中同步对共享资源的访问

请参见

---

参考

Thread
WaitOne
WaitAny
WaitAll
Monitor
Mutex
AutoResetEvent
ManualResetEvent
Interlocked
WaitHandle

概念

C# 编程指南

  一个简单的C#多线程间同步的例子 收藏

在开发中经常会遇到线程的例子，如果某个后台操作比较费时间，我们就可以启动一个线程去执行那个费时的操作，同时程序继续执行。在某些情况下可能会出现多个线程的同步协同的问题，下面的例子就展示了在两个线程之间如何协同工作。

这个程序的思路是共同做一件事情（从一个ArrayList中删除元素）,如果执行完成了，两个线程都停止执行。

代码如下：

using  System;
using  System.Collections;
using  System.Collections.Generic;
using  System.Threading;

///   <summary>
///  在开发中经常会遇到线程的例子，如果某个后台操作比较费时间，我们就可以启动一个线程去执行那个费时的操作，同时程序继续执行。在某些情况下可能会出现多个线程的同步协同的问题，下面的例子就展示了在两个线程之间如何协同工作。
///
/// 这个程序的思路是共同做一件事情（从一个ArrayList中删除元素）,如果执行完成了，两个线程都停止执行。
/// 作者：周公
///  时间：2008-5-17
///  原发地址： http://blog.csdn.net/zhoufoxcn
///   </summary>
public   class  ThreadDemo
{
     private  Thread threadOne;
     private  Thread threadTwo;
     private  ArrayList stringList;
     private   event  EventHandler OnNumberClear; // 数据删除完成引发的事件
     public   static   void  Main()
    {
        ThreadDemo demo  =   new  ThreadDemo( 1000 );
        demo.Action();
    }
     public  ThreadDemo( int  number)
    {
        Random random  =   new  Random( 1000000 );
        stringList  =   new  ArrayList(number);
         for  ( int  i  =   0 ; i  <  number; i ++ )
        {
            stringList.Add(random.Next().ToString());
        }
        threadOne  =   new  Thread( new  ThreadStart(Run)); // 两个线程共同做一件事情
        threadTwo  =   new  Thread( new  ThreadStart(Run)); // 两个线程共同做一件事情
        threadOne.Name  =   " 线程1 " ;
        threadTwo.Name  =   " 线程2 " ;
        OnNumberClear  +=   new  EventHandler(ThreadDemo_OnNumberClear);
        
    }
     ///   <summary>
     ///  开始工作
     ///   </summary>
     public   void  Action()
    {
        threadOne.Start();
        threadTwo.Start();
    }
     ///   <summary>
     ///  共同做的工作
     ///   </summary>
     private   void  Run()
    {
         string  stringValue  =   null ;
         while  ( true )
        {
            Monitor.Enter( this ); // 锁定，保持同步
            stringValue  =  ( string )stringList[ 0 ];
            Console.WriteLine(Thread.CurrentThread.Name  +   " 删除了 "   +  stringValue);
            stringList.RemoveAt( 0 ); // 删除ArrayList中的元素
             if  (stringList.Count  ==   0 )
            {
                OnNumberClear( this ,  new  EventArgs()); // 引发完成事件
            }
            Monitor.Exit( this ); // 取消锁定
            Thread.Sleep( 5 );
        }
    }

     // 执行完成之后，停止所有线程
     void  ThreadDemo_OnNumberClear( object  sender, EventArgs e)
    {
        Console.WriteLine( " 执行完了，停止了所有线程的执行。 " );
        threadTwo.Abort();
        threadOne.Abort();
        
    }
}

说明：要实现线程同步不止这一种方式。在这里采用了事件，在事件处理程序里中止了线程（主要是回答csdn论坛的一个朋友的问题才用了这种办法）。

http://blog.csdn.net/zhoufoxcn/archive/2008/05/17/2453803.aspx

http://msdn.microsoft.com/zh-cn/library/ms173179(VS.80).aspx