深入浅出多线程系列之五：一些同步构造(下篇)

1：CountdownEvent

Framework 4.0提供了一个CountdownEvent类，主要是让你等待多个线程。考虑下这样的场景：

有一个任务，3个人去做，你需要等这3个人都做完了才继续下一步操作。

下面就是：

class Thread15
    {
        static CountdownEvent _countdown = new CountdownEvent(3);

        public static void MainThread()
        {
            new Thread(SaySomething).Start("I'm thread 1");
            new Thread(SaySomething).Start("I'm thread 2");
            new Thread(SaySomething).Start("I'm thread 3");

            _countdown.Wait(); //阻塞，直到Signal被调用三次
            Console.WriteLine("All threads have finished speaking!");
        }

        static void SaySomething(object thing)
        {
            Thread.Sleep(1000);
            Console.WriteLine(thing);
            _countdown.Signal();
        }
    }

注意在构造函数中我们传递了3.代表我们要等待3个线程都结束。

2：ThreadPool.RegisterWaitForSingleObject

如果你的应用程序中有大量的线程都在一个WaitHandle上花费了大量的时间的时候，

你可以通过线程池的ThreadPool.RegisterWaitForSingleObject方法来提高资源的利用率，这个方法接受一个委托，当这个WaitHandle调用signal方法后，

方法的委托就会被执行了。 

class Thread16
    {
        static ManualResetEvent _starter = new ManualResetEvent(false);

        public static void MainThread()
        {
            RegisteredWaitHandle reg = ThreadPool.RegisterWaitForSingleObject
                (_starter, Go, "Some Data", -1, true); 
　　　　　　//在_starter上等待执行Go方法，-1,代表永远不超时，true代表只执行一遍,”Some Data”是传递的参数

            Thread.Sleep(5000);
            Console.WriteLine("Signaling worker...");
            _starter.Set(); 　　　　//唤醒等待的线程
            Console.ReadLine();
            reg.Unregister(_starter);  //取消注册。
        }

        static void Go(object data, bool timeOut)
        {
            Console.Write("Started - " + data);
            Console.WriteLine("ThreadId:" + Thread.CurrentThread.ManagedThreadId);
        }

    }

3：同步上下文：

通过继承ContextBoundObject类，并且加上Synchronization特性，CLR会自动的为你的操作加锁。

//继承自ContextBoundObject，且加上Synchronization特性修饰
    [Synchronization]
    public class AutoLock:ContextBoundObject
    {
        public void Demo()
        {
            Console.WriteLine("Start...");
            Thread.Sleep(1000);
            Console.WriteLine("end");
        }
    }
//主线程：
    public static void MainThread()
        {
            AutoLock safeInstance = new AutoLock();
            new Thread(safeInstance.Demo).Start();
            new Thread(safeInstance.Demo).Start();
            safeInstance.Demo();
        }

输出为:

Start…

End

Start…

End

Start…

End

CLR会确保一次只有一个线程可以执行safeInstance里面的代码，它会自动的创建一个同步对象，然后

在每次调用方法或属性的时候都 lock它，从这个角度来讲safeInstance是一个同步上下文。

但是它是怎么样工作的，在Synchronization特性和System.Runtime.Remoting.Contexts命名空间中存在着线索。

一个ContextBoundObject被认为是一个远程(“remote”)对象.意味所有的方法调用都可以被介入。当我们实例化AutoLock的时候，CLR实际上返回了一个proxy对象，一个和AutoLock对象有着同样方法，同样属性的Proxy对象，在这里它扮演者中介的对象。这样就为自动加锁提供了介入的机会，在每一次方法调用上都会花费几微妙的时间来介入。

你可能会认为下面的代码会和上面的一样，是一样的输出结果：

//继承自ContextBoundObject，且加上Synchronization特性修饰
    [Synchronization]
    public class AutoLock:ContextBoundObject
    {
        public void Demo()
        {
            Console.WriteLine("Start...");
            Thread.Sleep(1000);
            Console.WriteLine("end");
        }

        public void Test()
        {
            new Thread(Demo).Start();
            new Thread(Demo).Start();
            new Thread(Demo).Start();
            Console.ReadLine();
        }

        public static void RunTest()
        {
            new AutoLock().Test();
        }
    }

public static void MainThread()
        {
            //AutoLock safeInstance = new AutoLock();
            //new Thread(safeInstance.Demo).Start();
            //new Thread(safeInstance.Demo).Start();
            //safeInstance.Demo();

            AutoLock.RunTest();
        }

实际上这里我们会运行到Console.ReadLine方法这里，然后等待输入。

为什么？？

因为CLR会确保一次只有一个线程能够执行AutoLock的代码，所以当主线程执行到Console.ReadLine方法的时候，

就开始等待输入了。如果你按下Enter，代码就和上面的输出一样了。

注：还有一些同步构造将在以后讲到.

参考资料：

http://www.albahari.com/threading/

CLR Via C# 3.0