『C#基础』多线程笔记「二」线程同步

文章结构：

1. 锁定
2. 监视器
3. 共享资源的同步访问
4. 同步事件和等待句柄
5. 多线程使用准则「MSDN」

锁定

无论是程序还是数据库，只要是涉及到并发的问题，都难免会有「锁」的概念。

在C#中，使用lock关键字来对某个对象实施加锁的操作。

lock 关键字将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。

            public static string lockTest = string.Empty;  // 用于测试线程锁
         
            。。。。。。

            /* 关于lock关键字：
             *     lock必须有一个参数对象，且这个参数对象必须是引用类型的，也就是说，不可以是int等；
             *     参数对象不可以是用来定义锁的范围的，这个范围主要取决于参数对象的可访问限制，private/internal/public等；
             *     这个提供的对象是用来唯一的标识由多个线程共享的资源，也通常表示需要进行线程同步的资源；
             *     也就是说，当资源对象「R1」被线程「T1」锁住后，假如线程「T2」想要使用「R1」，就必须要等「T1」执行完才可以；
             *     尽量不是锁定「public」类型的对象，特别是字条串，因为这样可能会造成不可预知的问题；
             *     也就是说，如果我定义了一个资源「R1」，我在「T1」中要使用「R1」，所以我在「T1」中执行lock(「R1」)，
             *     然后，「T2」也想要访问「R1」，但是因为此时「R1」已经被「T1」锁定，所以「T2」的申请是失败的，
             *     所以「T2」会开始等待，等待「T1」执行完并释放「R1」；
             *     
             */
            lock (lockTest)
            {
                lockTest = Thread.CurrentThread.Name;

                Console.WriteLine("\n\n" + Thread.CurrentThread.Name + ":\tLock Block starting...");
                for (int i = 0; i < 10; i++)
                    Console.WriteLine(lockTest + ":\t"+i+"th");
                Console.WriteLine(Thread.CurrentThread.Name + ":\tLock Block end." + "\n\n");
            }

监视器

当多个线程公用一个对象的时候，应该使用监视器类「System.Threading.Monitor」，而不是锁「lock」。

首先，Monitor的作用与lock关键字类似，都是防止多个线程同时执行代码块。

            object objLock = null;
            lock (objLock)
            {
                // To do something...
            }
         // 等效于
            object objMonitor = null;
            System.Threading.Monitor.Enter(objMonitor);
            try
            {
                // To do something...
            }
            finally
            {
                System.Threading.Monitor.Exit(objMonitor);
            }

其次，在对小型的代码块进行操作的时候，显然使用lock关键字更加的简洁。

但是，如果要实现一个很复杂的逻辑，或者要根据线程的远行情况来对当前锁定的对象进行控制的话，显然Monitor就更加的方便了。

而且，就MSDN上的说明，lock关键字的内部实现也是使用的Monitor，只不过其只是调用了「Enter」「Exit」这两个方法，并且加代码块中的代码放于「Try…Finally…」中。

在使用的时候，一定要注意的就是Monitor只是针对引用类型对象的操作，而不是对值类型的操作。

如果使用了值类型，就会引发「从不同步的代码块中调用了对象同步方法」。

这主要是因为：

Monitor 将锁定对象（即引用类型）而非值类型。 在您将值类型传递给 Enter 和 Exit 时，它会针对每个调用分别装箱。 由于每个调用都创建一个单独的对象，所以 Enter 从不拦截，并且其旨在保护的代码并未真正同步。 此外，传递给 Exit 的对象不同于传递给 Enter 的对象，所以 Monitor 将引发 SynchronizationLockException，并显示消息“从不同步的代码块中调用了对象同步方法”。下面的示例演示这些问题。

除了使用Monitor与lock以外，还可以使用「Mutex」提供对资源的独占访问。Mutex 类比 Monitor 类使用更多系统资源，但是它可以跨应用程序域边界进行封送处理，可用于多个等待，并且可用于同步不同进程中的线程。「MSDN」

名称	说明
Enter(Object)	在指定对象上获取排他锁。
Enter(Object, Boolean)	获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
Exit	释放指定对象上的排他锁。
Pulse	通知等待队列中的线程锁定对象状态的更改。
PulseAll	通知所有的等待线程对象状态的更改。
TryEnter(Object)	尝试获取指定对象的排他锁。
TryEnter(Object, Boolean)	尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
TryEnter(Object, Int32)	在指定的毫秒数内尝试获取指定对象上的排他锁。
TryEnter(Object, TimeSpan)	在指定的时间量内尝试获取指定对象上的排他锁。
TryEnter(Object, Int32, Boolean)	在指定的毫秒数中，尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
TryEnter(Object, TimeSpan, Boolean)	在指定的一段时间内，尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
Wait(Object)	释放对象上的锁并阻止当前线程，直到它重新获取该锁。
Wait(Object, Int32)	释放对象上的锁并阻止当前线程，直到它重新获取该锁。 如果指定的超时间隔已过，则线程进入就绪队列。
Wait(Object, TimeSpan)	释放对象上的锁并阻止当前线程，直到它重新获取该锁。 如果指定的超时间隔已过，则线程进入就绪队列。
Wait(Object, Int32, Boolean)	释放对象上的锁并阻止当前线程，直到它重新获取该锁。 如果指定的超时间隔已过，则线程进入就绪队列。 此方法还指定是否在等待之前退出上下文的同步域（如果处于同步上下文中的话）然后重新获取该同步域。
Wait(Object, TimeSpan, Boolean)	释放对象上的锁并阻止当前线程，直到它重新获取该锁。 如果指定的超时间隔已过，则线程进入就绪队列。 可以在等待之前退出同步上下文的同步域，随后重新获取该域。

using System;
using System.Threading;

// Note: The class whose internal public member is the synchronizing
// method is not public; none of the client code takes a lock on the
// Resource object.The member of the nonpublic class takes the lock on
// itself. Written this way, malicious code cannot take a lock on
// a public object.
class SyncResource
{
    public void Access(Int32 threadNum)
    {
        // Uses Monitor class to enforce synchronization.
        lock (this)
        {
            // Synchronized: Despite the next conditional, each thread
            // waits on its predecessor.
            if (threadNum % 2 == 0)
            {
                Thread.Sleep(2000);
            }
            Console.WriteLine("Start Synched Resource access (Thread={0})", threadNum);
            Thread.Sleep(200);
            Console.WriteLine("Stop Synched Resource access  (Thread={0})", threadNum);
        }
    }
}

// Without the lock, the method is called in the order in which threads reach it.
class UnSyncResource
{
    public void Access(Int32 threadNum)
    {
        // Does not use Monitor class to enforce synchronization.
        // The next call throws the thread order.
        if (threadNum % 2 == 0)
        {
            Thread.Sleep(2000);
        }
        Console.WriteLine("Start UnSynched Resource access (Thread={0})", threadNum);
        Thread.Sleep(200);
        Console.WriteLine("Stop UnSynched Resource access  (Thread={0})", threadNum);
    }
}

public class App
{
    static Int32 numAsyncOps = 5;
    static AutoResetEvent asyncOpsAreDone = new AutoResetEvent(false);
    static SyncResource SyncRes = new SyncResource();
    static UnSyncResource UnSyncRes = new UnSyncResource();

    public static void Main()
    {
        for (Int32 threadNum = 0; threadNum < 5; threadNum++)
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(SyncUpdateResource), threadNum);
        }

        // Wait until this WaitHandle is signaled.
        asyncOpsAreDone.WaitOne();
        Console.WriteLine("\t\nAll synchronized operations have completed.\t\n");

        // Reset the thread count for unsynchronized calls.
        numAsyncOps = 5;

        for (Int32 threadNum = 0; threadNum < 5; threadNum++)
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(UnSyncUpdateResource), threadNum);
        }

        // Wait until this WaitHandle is signaled.
        asyncOpsAreDone.WaitOne();
        Console.WriteLine("\t\nAll unsynchronized thread operations have completed.");
    }

    // The callback method's signature MUST match that of a
    // System.Threading.TimerCallback delegate (it takes an Object
    // parameter and returns void).
    static void SyncUpdateResource(Object state)
    {
        // This calls the internal synchronized method, passing
        // a thread number.
        SyncRes.Access((Int32) state);

        // Count down the number of methods that the threads have called.
        // This must be synchronized, however; you cannot know which thread
        // will access the value **before** another thread's incremented
        // value has been stored into the variable.
        if (Interlocked.Decrement(ref numAsyncOps) == 0)
        {
            // Announce to Main that in fact all thread calls are done.
            asyncOpsAreDone.Set();
        }
    }

    // The callback method's signature MUST match that of a
    // System.Threading.TimerCallback delegate (it takes an Object
    // parameter and returns void).
    static void UnSyncUpdateResource(Object state)
    {
        // This calls the unsynchronized method, passing a thread number.
        UnSyncRes.Access((Int32) state);

        // Count down the number of methods that the threads have called.
        // This must be synchronized, however; you cannot know which thread
        // will access the value **before** another thread's incremented
        // value has been stored into the variable.
        if (Interlocked.Decrement(ref numAsyncOps) == 0)
        {
            // Announce to Main that in fact all thread calls are done.
            asyncOpsAreDone.Set();
        }
    }
}

            try
            {
                if (Monitor.TryEnter(workerA))
                {
                    Monitor.PulseAll(workerA);
                    monitorTest = "Monitor\t" + Thread.CurrentThread.Name;

                    Console.WriteLine("\n\n" + Thread.CurrentThread.Name + ":\tLock Block starting...");
                    for (int i = 0; i < 10; i++)
                        Console.WriteLine(workerA.WorkerName + ":\t" + i + "th");
                    Console.WriteLine(Thread.CurrentThread.Name + ":\tLock Block end." + "\n\n");
                    Monitor.PulseAll(workerA);
                }
            }
            finally
            {
                Monitor.Exit(workerA);
            }

共享资源的同步访问

在多线程环境中保护模块中的全局数据：

1. 应该程序中所有的线程都可以访问方法中的公用字段。
2. 要同步对公用字段的访问，可以使用属性替代字段，并使用ReaderWriterLock对象控制访问。
3. ReaderWriterLock：定义支持单个写线程和多个读线程的锁。
4. 要注意ReaderWriterLock的ReleaseLock、ReleaseReaderLock、ReleaseWriterLock方法。
5. 「MSDN」建议使用 ReaderWriterLockSlim 而不是 ReaderWriterLock。
6. 长时间持有读线程锁或写线程锁会使其他线程发生饥饿 (starve)。 为了得到最好的性能，需要考虑重新构造应用程序以将写访问的持续时间减少到最小。

// This example shows a ReaderWriterLock protecting a shared
// resource that is read concurrently and written exclusively
// by multiple threads.

// The complete code is located in the ReaderWriterLock
// class topic.
using System;
using System.Threading;

public class Test
{
    // Declaring the ReaderWriterLock at the class level
    // makes it visible to all threads.
    static ReaderWriterLock rwl = new ReaderWriterLock();
    // For this example, the shared resource protected by the
    // ReaderWriterLock is just an integer.
    static int resource = 0;

    const int numThreads = 26;
    static bool running = true;
    static Random rnd = new Random();

    // Statistics.
    static int readerTimeouts = 0;
    static int writerTimeouts = 0;
    static int reads = 0;
    static int writes = 0;

    public static void Main(string[] args)
    {
        // Start a series of threads. Each thread randomly
        // performs reads and writes on the shared resource.
        Thread[] t = new Thread[numThreads];
        for (int i = 0; i < numThreads; i++)
        {
            t[i] = new Thread(new ThreadStart(ThreadProc));
            t[i].Name = new String(Convert.ToChar(i + 65), 1);
            t[i].Start();
            if (i > 10)
                Thread.Sleep(300);
        }

        // Tell the threads to shut down, then wait until they all
        // finish.
        running = false;
        for (int i = 0; i < numThreads; i++)
        {
            t[i].Join();
        }

        // Display statistics.
        Console.WriteLine("\r\n{0} reads, {1} writes, {2} reader time-outs, {3} writer time-outs.",
            reads, writes, readerTimeouts, writerTimeouts);
        Console.WriteLine("Press ENTER to exit.");
        Console.ReadLine();
    }

    static void ThreadProc()
    {
        // As long as a thread runs, it randomly selects
        // various ways to read and write from the shared 
        // resource. Each of the methods demonstrates one 
        // or more features of ReaderWriterLock.
        while (running)
        {
            double action = rnd.NextDouble();
            if (action < .8)
                ReadFromResource(10);
            else if (action < .81)
                ReleaseRestore(50);
            else if (action < .90)
                UpgradeDowngrade(100);
            else
                WriteToResource(100);
        }
    }

    // Shows how to request and release a reader lock, and
    // how to handle time-outs.
    static void ReadFromResource(int timeOut)
    {
        try
        {
            rwl.AcquireReaderLock(timeOut);
            try
            {
                // It is safe for this thread to read from
                // the shared resource.
                Display("reads resource value " + resource); 
                Interlocked.Increment(ref reads);
            }        
            finally
            {
                // Ensure that the lock is released.
                rwl.ReleaseReaderLock();
            }
        }
        catch (ApplicationException)
        {
            // The reader lock request timed out.
            Interlocked.Increment(ref readerTimeouts);
        }
    }

    // Shows how to request and release the writer lock, and
    // how to handle time-outs.
    static void WriteToResource(int timeOut)
    {
        try
        {
            rwl.AcquireWriterLock(timeOut);
            try
            {
                // It is safe for this thread to read or write
                // from the shared resource.
                resource = rnd.Next(500);
                Display("writes resource value " + resource);
                Interlocked.Increment(ref writes);
            }        
            finally
            {
                // Ensure that the lock is released.
                rwl.ReleaseWriterLock();
            }
        }
        catch (ApplicationException)
        {
            // The writer lock request timed out.
            Interlocked.Increment(ref writerTimeouts);
        }
    }

    // Shows how to request a reader lock, upgrade the
    // reader lock to the writer lock, and downgrade to a
    // reader lock again.
    static void UpgradeDowngrade(int timeOut)
    {
        try
        {
            rwl.AcquireReaderLock(timeOut);
            try
            {
                // It is safe for this thread to read from
                // the shared resource.
                Display("reads resource value " + resource); 
                Interlocked.Increment(ref reads);

                // If it is necessary to write to the resource,
                // you must either release the reader lock and 
                // then request the writer lock, or upgrade the
                // reader lock. Note that upgrading the reader lock
                // puts the thread in the write queue, behind any
                // other threads that might be waiting for the 
                // writer lock.
                try
                {
                    LockCookie lc = rwl.UpgradeToWriterLock(timeOut);
                    try
                    {
                        // It is safe for this thread to read or write
                        // from the shared resource.
                        resource = rnd.Next(500);
                        Display("writes resource value " + resource);
                        Interlocked.Increment(ref writes);
                    }        
                    finally
                    {
                        // Ensure that the lock is released.
                        rwl.DowngradeFromWriterLock(ref lc);
                    }
                }
                catch (ApplicationException)
                {
                    // The upgrade request timed out.
                    Interlocked.Increment(ref writerTimeouts);
                }

                // When the lock has been downgraded, it is 
                // still safe to read from the resource.
                Display("reads resource value " + resource); 
                Interlocked.Increment(ref reads);
            }        
            finally
            {
                // Ensure that the lock is released.
                rwl.ReleaseReaderLock();
            }
        }
        catch (ApplicationException)
        {
            // The reader lock request timed out.
            Interlocked.Increment(ref readerTimeouts);
        }
    }

    // Shows how to release all locks and later restore
    // the lock state. Shows how to use sequence numbers
    // to determine whether another thread has obtained
    // a writer lock since this thread last accessed the
    // resource.
    static void ReleaseRestore(int timeOut)
    {
        int lastWriter;

        try
        {
            rwl.AcquireReaderLock(timeOut);
            try
            {
                // It is safe for this thread to read from
                // the shared resource. Cache the value. (You
                // might do this if reading the resource is
                // an expensive operation.)
                int resourceValue = resource;
                Display("reads resource value " + resourceValue); 
                Interlocked.Increment(ref reads);

                // Save the current writer sequence number.
                lastWriter = rwl.WriterSeqNum;

                // Release the lock, and save a cookie so the
                // lock can be restored later.
                LockCookie lc = rwl.ReleaseLock();

                // Wait for a random interval (up to a 
                // quarter of a second), and then restore
                // the previous state of the lock. Note that
                // there is no time-out on the Restore method.
                Thread.Sleep(rnd.Next(250));
                rwl.RestoreLock(ref lc);

                // Check whether other threads obtained the
                // writer lock in the interval. If not, then
                // the cached value of the resource is still
                // valid.
                if (rwl.AnyWritersSince(lastWriter))
                {
                    resourceValue = resource;
                    Interlocked.Increment(ref reads);
                    Display("resource has changed " + resourceValue);
                }
                else
                {
                    Display("resource has not changed " + resourceValue);
                }
            }        
            finally
            {
                // Ensure that the lock is released.
                rwl.ReleaseReaderLock();
            }
        }
        catch (ApplicationException)
        {
            // The reader lock request timed out.
            Interlocked.Increment(ref readerTimeouts);
        }
    }

    // Helper method briefly displays the most recent
    // thread action. Comment out calls to Display to 
    // get a better idea of throughput.
    static void Display(string msg)
    {
        Console.Write("Thread {0} {1}.       \r", Thread.CurrentThread.Name, msg);
    }
}

同步事件和等待句柄

同步事件：

1. AutoResetEvent：只要激活线程，它的状态将自动从终止变为非终止。
2. ManualResetEvent：允许它的终止状态激活任意多个线程，只有它的Reset方法被调用的时候才还原到非终止状态。

using System;
using System.Threading;

// Visual Studio: Replace the default class in a Console project with 
//                the following class.
class Example
{
    private static AutoResetEvent event_1 = new AutoResetEvent(true);
    private static AutoResetEvent event_2 = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Press Enter to create three threads and start them.\r\n" +
                          "The threads wait on AutoResetEvent #1, which was created\r\n" +
                          "in the signaled state, so the first thread is released.\r\n" +
                          "This puts AutoResetEvent #1 into the unsignaled state.");
        Console.ReadLine();

        for (int i = 1; i < 4; i++)
        {
            Thread t = new Thread(ThreadProc);
            t.Name = "Thread_" + i;
            t.Start();
        }
        Thread.Sleep(250);

        for (int i = 0; i < 2; i++)
        {
            Console.WriteLine("Press Enter to release another thread.");
            Console.ReadLine();
            event_1.Set();
            Thread.Sleep(250);
        }

        Console.WriteLine("\r\nAll threads are now waiting on AutoResetEvent #2.");
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("Press Enter to release a thread.");
            Console.ReadLine();
            event_2.Set();
            Thread.Sleep(250);
        }

        // Visual Studio: Uncomment the following line.
        //Console.Readline();
    }

    static void ThreadProc()
    {
        string name = Thread.CurrentThread.Name;

        Console.WriteLine("{0} waits on AutoResetEvent #1.", name);
        event_1.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #1.", name);

        Console.WriteLine("{0} waits on AutoResetEvent #2.", name);
        event_2.WaitOne();
        Console.WriteLine("{0} is released from AutoResetEvent #2.", name);

        Console.WriteLine("{0} ends.", name);
    }
}

/* This example produces output similar to the following:

Press Enter to create three threads and start them.
The threads wait on AutoResetEvent #1, which was created
in the signaled state, so the first thread is released.
This puts AutoResetEvent #1 into the unsignaled state.

Thread_1 waits on AutoResetEvent #1.
Thread_1 is released from AutoResetEvent #1.
Thread_1 waits on AutoResetEvent #2.
Thread_3 waits on AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #1.
Press Enter to release another thread.

Thread_3 is released from AutoResetEvent #1.
Thread_3 waits on AutoResetEvent #2.
Press Enter to release another thread.

Thread_2 is released from AutoResetEvent #1.
Thread_2 waits on AutoResetEvent #2.

All threads are now waiting on AutoResetEvent #2.
Press Enter to release a thread.

Thread_2 is released from AutoResetEvent #2.
Thread_2 ends.
Press Enter to release a thread.

Thread_1 is released from AutoResetEvent #2.
Thread_1 ends.
Press Enter to release a thread.

Thread_3 is released from AutoResetEvent #2.
Thread_3 ends.
 */

多线程使用准则「MSDN」：

• 不要使用 Thread.Abort 终止其他线程。 对另一个线程调用 Abort 无异于引发该线程的异常，也不知道该线程已处理到哪个位置。

• 不要使用 Thread.Suspend 和 Thread.Resume 同步多个线程的活动。 请使用 Mutex、ManualResetEvent、AutoResetEvent 和 Monitor。

• 不要从主程序中控制辅助线程的执行（如使用事件）， 而应在设计程序时让辅助线程负责等待任务，执行任务，并在完成时通知程序的其他部分。 如果不阻止辅助线程，请考虑使用线程池线程。 如果阻止辅助线程，Monitor.PulseAll 会很有帮助。

• 不要将类型用作锁定对象。 例如，避免在 C# 中使用 lock(typeof(X)) 代码，或在 Visual Basic 中使用 SyncLock(GetType(X)) 代码，或将 Monitor.Enter 和 Type 对象一起使用。 对于给定类型，每个应用程序域只有一个 System.Type 实例。 如果您锁定的对象的类型是 public，您的代码之外的代码也可锁定它，但会导致死锁。 有关其他信息，请参见可靠性最佳做法。

• 锁定实例时要谨慎，例如，C# 中的 lock(this) 或 Visual Basic 中的 SyncLock(Me)。 如果您的应用程序中不属于该类型的其他代码锁定了该对象，则会发生死锁。

• 一定要确保已进入监视器的线程始终离开该监视器，即使当线程在监视器中时发生异常也是如此。 C# 的 lock 语句和 Visual Basic 的 SyncLock 语句可自动提供此行为，它们用一个 finally块来确保调用 Monitor.Exit。 如果无法确保调用 Exit，请考虑将您的设计更改为使用 Mutex。 Mutex 在当前拥有它的线程终止后会自动释放。

• 一定要针对那些需要不同资源的任务使用多线程，避免向单个资源指定多个线程。 例如，任何涉及 I/O 的任务都会从其拥有其自己的线程这一点得到好处，因为此线程在 I/O 操作期间将阻止，从而允许其他线程执行。 用户输入是另一种可从专用线程获益的资源。 在单处理器计算机上，涉及大量计算的任务可与用户输入和涉及 I/O 的任务并存，但多个计算量大的任务将相互竞争。

• 对于简单的状态更改，请考虑使用 Interlocked 类的方法，而不是 lock 语句（在 Visual Basic 中为 SyncLock）。 lock 语句是一个优秀的通用工具，但是 Interlocked 类为必须是原子性的更新提供了更好的性能。 如果没有争夺，它会在内部执行一个锁定前缀。 在查看代码时，请注意类似于以下示例所示的代码。 在第一个示例中，状态变量是递增的：

其他参考：

1. http://msdn.microsoft.com/zh-cn/library/ms173179.aspx
2. http://msdn.microsoft.com/zh-cn/library/z8chs7ft.aspx
3. http://msdn.microsoft.com/zh-cn/library/dd997305.aspx
4. http://msdn.microsoft.com/zh-cn/magazine/cc163352.aspx    「死锁监控」
5. http://msdn.microsoft.com/zh-cn/library/3e8s7xdd.aspx           「托管线程」