23 C# 第十九章(一) 基于 .Net 4 TPL 的同步和线程处理模式

最新推荐文章于 2024-07-19 17:59:57 发布

zy__

最新推荐文章于 2024-07-19 17:59:57 发布

阅读量1.8k

点赞数

分类专栏： C#

本文链接：https://blog.csdn.net/wangzhiyu1980/article/details/10484283

版权

C# 专栏收录该内容

43 篇文章 0 订阅

订阅专栏

同步

多线程编程的复杂性在于识别多个线程可能同时访问的数据。同步可以防止数据的同时访问。

使用Monitor

Monitor 可以看作是一个监视器，来阻止第二个线程进入一个受保护的代码段，直到第一个线程退出代码段。

Monitor主要使用的是Monitor.Enter() 和 Monitor.Exit()，但要保证Monitor.Exit()一定被调用，防止其长时间的阻止其他线程进入。

Monitor 代码实例：

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;


namespace TPL_Sync_Sample_Simple_Monitor
{
    class Program
    {
        readonly static object _Sync = new object();
        const int _Total = 1000;
        static long _Count = 0;


        static void Main(string[] args)
        {
            Task task = Task.Factory.StartNew(Decrement);
            for (int i = 0; i < _Total; i++)
            {
                bool lockToken = false;

                Monitor.Enter(_Sync, ref lockToken);
                try
                {
                    _Count++;
                    Console.WriteLine("Count ++ : {0}", _Count);
                }
                finally
                {
                    if (lockToken)
                    {
                        Monitor.Exit(_Sync);
                    }
                }
            }
            task.Wait();
            Console.WriteLine("Count = {0}", _Count);

            Console.ReadKey();
        }

        static void Decrement()
        {
            for (int i = 0; i < _Total; i++)
            {
                bool lockToken = false;

                Monitor.Enter(_Sync, ref lockToken);
                try
                {
                    _Count--;
                    Console.WriteLine("Count -- : {0}", _Count);
                }
                finally
                {
                    if (lockToken)
                    {
                        Monitor.Exit(_Sync);
                    }
                }
            }
        }
    }
}

使用Lock

当使用Monitor时会频繁的使用try / finally 来保证一定会调用Monitor.Exit()。这里提供了一种 lock 的锁定方式。效果与Monitor一样。

Lock 代码实例：

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;


namespace TPL_Sync_Sample_Simple_Lock
{
    class Program
    {
        readonly static object _Sync = new object();
        const int _Total = 1000;
        static long _Count = 0;


        static void Main(string[] args)
        {
            Task task = Task.Factory.StartNew(Decrement);
            for (int i = 0; i < _Total; i++)
            {
                lock (_Sync)
                {
                    _Count++;
                    Console.WriteLine("++ {0}  ", _Count);
                }
            }

            task.Wait();
            Console.WriteLine("Count = {0}", _Count);

            Console.ReadKey();
        }

        static void Decrement()
        {
            for (int i = 0; i < _Total; i++)
            {
                lock (_Sync)
                {
                    _Count--;
                    Console.WriteLine("-- {0}  ", _Count);
                }
            }
        }
    }
}

加锁对象的选择

无论使用lock 还是 Monitor，都要小心的选择所要lock的对象。

例如程序中定义的对象

readonly static object _Sync = new object();

readonly 保证在 Monitor.Enter和Monitor.Exit中间值不会被改变。

private 保证类外的同步块不会访问它。

而且同步对象不能是值类型的。

volatile

编译器和CPU会对代码进行优化，使指令不按其编码顺序执行，或取消某些指令，这在多线程程序中会造成出乎意料的结果。volatile 关键字强迫所有的读写操作都在代码指定的位置执行。

更多同步类型：

System.Threading.Mutex

System.Threading.Mutex 代码实例：

// This example shows how a Mutex is used to synchronize access
// to a protected resource. Unlike Monitor, Mutex can be used with
// WaitHandle.WaitAll and WaitAny, and can be passed across
// AppDomain boundaries.

using System;
using System.Threading;

class Test
{
    // Create a new Mutex. The creating thread does not own the
    // Mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create the threads that will use the protected resource.
        for (int i = 0; i < numThreads; i++)
        {
            Thread myThread = new Thread(new ThreadStart(MyThreadProc));
            myThread.Name = String.Format("Thread{0}", i + 1);
            myThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
        Console.ReadKey();
    }

    private static void MyThreadProc()
    {
        for (int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter.
        mut.WaitOne();

        Console.WriteLine("{0} has entered the protected area",
            Thread.CurrentThread.Name);

        // Place code to access non-reentrant resources here.

        // Simulate some work.
        Thread.Sleep(500);

        Console.WriteLine("{0} is leaving the protected area\r\n",
            Thread.CurrentThread.Name);

        // Release the Mutex.
        mut.ReleaseMutex();
    }
}

WaitHandle

WaitHandle代码实例：

using System;
using System.Threading;
using System.Threading.Tasks;


namespace TPL_Sync_Sample_WaitHandle_Task
{
    class Program
    {
        static ManualResetEventSlim MainSignaledResetEvent = new ManualResetEventSlim();
        static ManualResetEventSlim DoWorkSignaledResetEvent = new ManualResetEventSlim();

        public static void DoWork()
        {
            Console.WriteLine("DoWork Start().");
            DoWorkSignaledResetEvent.Set();
            MainSignaledResetEvent.Wait();
            Console.WriteLine("DoWork End().");
        }

        static void Main(string[] args)
        {
            {
                Console.WriteLine("Main Start().");

                Task task = Task.Factory.StartNew(DoWork);

                DoWorkSignaledResetEvent.Wait();
                Console.WriteLine("Main Execute.");

                MainSignaledResetEvent.Set();
                task.Wait();

                Console.WriteLine("Main End().");

                Console.ReadKey();
            }
        }
    }
}

semaphore

http://msdn.microsoft.com/zh-cn/library/vstudio/system.threading.semaphore.aspx

semaphore代码实例：

using System;
using System.Threading;

public class Example
{
    // A semaphore that simulates a limited resource pool.
    //
    private static Semaphore _pool;

    // A padding interval to make the output more orderly.
    private static int _padding;

    public static void Main()
    {
        // Create a semaphore that can satisfy up to three
        // concurrent requests. Use an initial count of zero,
        // so that the entire semaphore count is initially
        // owned by the main program thread.
        //
        _pool = new Semaphore(0, 3);

        // Create and start five numbered threads. 
        //
        for (int i = 1; i <= 5; i++)
        {
            Thread t = new Thread(new ParameterizedThreadStart(Worker));

            // Start the thread, passing the number.
            //
            t.Start(i);
        }

        // Wait for half a second, to allow all the
        // threads to start and to block on the semaphore.
        //
        Thread.Sleep(500);

        // The main thread starts out holding the entire
        // semaphore count. Calling Release(3) brings the 
        // semaphore count back to its maximum value, and
        // allows the waiting threads to enter the semaphore,
        // up to three at a time.
        //
        Console.WriteLine("Main thread calls Release(3).");
        _pool.Release(3);

        Console.WriteLine("Main thread exits.");

        Console.ReadKey();
    }

    private static void Worker(object num)
    {
        // Each worker thread begins by requesting the
        // semaphore.
        Console.WriteLine("Thread {0} begins " +
            "and waits for the semaphore.", num);
        _pool.WaitOne();

        // A padding interval to make the output more orderly.
        int padding = Interlocked.Add(ref _padding, 100);

        Console.WriteLine("Thread {0} enters the semaphore.", num);

        // The thread's "work" consists of sleeping for 
        // about a second. Each thread "works" a little 
        // longer, just to make the output more orderly.
        //
        Thread.Sleep(1000 + padding);

        Console.WriteLine("Thread {0} releases the semaphore.", num);
        Console.WriteLine("Thread {0} previous semaphore count: {1}",
            num, _pool.Release());
    }
}

本地线程存储

利用线程本地存储，线程可以有一个专属的变量实例，实现了一种隔离的方式。

线程本地存储代码实例：

using System;
using System.Threading;

namespace TPL_Sync_Sample_ThreadLocal
{
    class Program
    {
        static ThreadLocal<int> _Count = new ThreadLocal<int>(()=>0);

        public static int Count
        {
            get { return _Count.Value; }
            set { _Count.Value = value; }
        }


        static void Main(string[] args)
        {
            Thread thread = new Thread(Decrement);
            thread.Start();


            for (int i = 0; i < 1000; i++)
            {
                Count++;
            }

            thread.Join();
            Console.WriteLine("Main Count = {0} ", Count);

            Console.ReadKey();
        }

        static void Decrement()
        {
            for (int i = 0; i < 1000; i++)
            {
                Count--;
            }

            Console.WriteLine("Thread Count = {0}", Count);
        }
    }
}

Timer 的使用

1) System.Windows.Forms.Timer
为用户界面编程

2) System.Timers.Timer
如果需要容纳在一个IContainer中，则使用它

3) System.Threading.Timer
如果不需要System.Timers.Timer的专门功能，则可以使用它，它是一个稍微轻量级的实现。

System.Threading.Timer 代码实例：

http://msdn.microsoft.com/zh-cn/library/vstudio/system.threading.timer.aspx

using System;
using System.Threading;

class TimerExample
{
    static void Main()
    {
        // Create an event to signal the timeout count threshold in the
        // timer callback.
        AutoResetEvent autoEvent = new AutoResetEvent(false);

        StatusChecker statusChecker = new StatusChecker(10);

        // Create an inferred delegate that invokes methods for the timer.
        TimerCallback tcb = statusChecker.CheckStatus;

        // Create a timer that signals the delegate to invoke 
        // CheckStatus after one second, and every 1/4 second 
        // thereafter.
        Console.WriteLine("{0} Creating timer.\n", DateTime.Now.ToString("h:mm:ss.fff"));
        Timer stateTimer = new Timer(tcb, autoEvent, 1000, 250);

        // When autoEvent signals, change the period to every
        // 1/2 second.
        autoEvent.WaitOne(5000, false);
        stateTimer.Change(0, 500);
        Console.WriteLine("\nChanging period.\n");

        // When autoEvent signals the second time, dispose of 
        // the timer.
        autoEvent.WaitOne(5000, false);
        stateTimer.Dispose();
        Console.WriteLine("\nDestroying timer.");

        Console.ReadKey();
    }
}

class StatusChecker
{
    private int invokeCount;
    private int maxCount;

    public StatusChecker(int count)
    {
        invokeCount = 0;
        maxCount = count;
    }

    // This method is called by the timer delegate.
    public void CheckStatus(Object stateInfo)
    {
        AutoResetEvent autoEvent = (AutoResetEvent)stateInfo;
        Console.WriteLine("{0} Checking status {1,2}.", DateTime.Now.ToString("h:mm:ss.fff"), (++invokeCount).ToString());

        if (invokeCount == maxCount)
        {
            // Reset the counter and signal Main.
            invokeCount = 0;
            autoEvent.Set();
        }
    }
}