C# 多线程（二）

在多线程的程序中，经常会出现两种情况：

一、应用程序中，线程把大部分的时间花费在等待状态，等待某个时间发生，然后给予响应。者一般使用ThreadPool（线程池）来解决；

二、线程平时都处于休眠状态，只是周期性地被唤醒。这一般使用Timer（定时器）来解决。

（四）多线程的自动管理（线程池）

ThreadPool提供一个由系统维护的线程池。将线程安放在线程池里，需要使用ThreadPool.QueueUserWorkItem()方法，该方法的原型如下：

//将一个线程放进线程池，该线程的Start() 方法将调用WaitCallback代理（delegate）对象代表的函数

public static bool QueueUserWorkItem(WaitCallback);

//重载的方法如下，参数object将传递给WaitCallback所代表的方法

public static bool QueueUserWorkItem(WaitCallback, object);

ThreadPool类是一个静态类。一旦使用该方法在线程池中添加了一个项目，那么该项目将是无法取消的。

在这里无需自己建立线程，只需把要做的工作写成函数，然后作为参数传递给ThreadPool.QueueUserWorkItem() 方法就可以了，传递的方法就是依靠WaitCallback代理对象。线程的建立、管理运行等工作都是由系统自动完成的。

ThreadPool的用法：

首先程序创建了一个ManualResetEvent对象，该对象就像一个信号灯，可以利用它的信号来通知其他线程。

本例中，当线程池中所有线程工作都完成以后，ManualResetEvent对象将被设置为有信号，从而通知主线程继续运行。

ManualResetEvent对象有几个重要的方法：

初始化该对象时，用户可以指定其默认的状态（有信号/无信号）

初始化后，该对象将保持原来的状态不变，直到它的Reset() 或者Set()方法被调用；

Set();   Reset();   设置为有信号/无信号状态

WaitOne()； 是当前线程挂起，直到ManualResetEvent对象处于有信号状态，此时该线程将被激活。然后，程序将向线程池中添加工作项，这些以函数形式提供的工作项被系统用来初始化自动建立的线程。当所有的线程都运行完了以后，ManualResetEvent.Set()方法被调用，应为调用了ManualResetEvent.WaitOne()方法而处在等待状态的主线程收到这个信号，于是它接着往下执行，完成后边的工作。

ThreadPool的用法示例：

（有待学习）

（五）多线程的自动管理（定时器）

Timer类：设置一个定时器，定时执行用户指定的函数。定时器启动后，系统将将自动建立一个新的线程，执行用户指定的函数。初始化一个Timer对象：

Timer timer = new Timer(timerDelegate, s, 1000, 1000);

//第一个参数：指定了TimerCallback委托，表示要执行的方法；

//第二个参数：一个包含回调方法要使用的信息的对象，或者为空引用

//第三个参数：延迟时间——计时开始的时刻距现在的时间，为“0”表示立即启动计时器；

//第四个参数：定时器的时间间隔——计时开始后，每个给定时长，TimerCallback所代表的方法将被调用一次。指定Timeout.Infinite可以禁用定时终止。

Timer.Change()方法：修改定时器的设置。

示例程序：

class TimerExampleState

{

public int counter = 0;

public Timer tmr;

}

class App

{

public static void Main()

{

TimerExampleState s = new TimerExampleState();

TimerCallback timerDelegate = new TimerCallback(fun);

Timer timer = new Timer(timerDelegate,s,1000,1000);

s.tmr = timer;

while(s.tmr!=null)

Thread.Sleep(0);

Console.WriteLine("Timer example done.");

}

static void fun( Object state)

{}

}

http://www.cnblogs.com/chinhr/archive/2008/04/15/1154444.html

（六）多线程学习（互斥对象）

转自： http://www.cnblogs.com/xugang/archive/2008/03/23/1118530.html

如何控制好多个线程相互之间的联系，不产生冲突和重复，这需要用到互斥对象，即：System.Threading 命名空间中的 Mutex 类。

我们可以把Mutex看作一个出租车，乘客看作线程。乘客首先等车，然后上车，最后下车。当一个乘客在车上时，其他乘客就只有等他下车以后才可以上车。而线程与Mutex对象的关系也正是如此，线程使用Mutex.WaitOne()方法等待Mutex对象被释放，如果它等待的Mutex对象被释放了，它就自动拥有这个对象，直到它调用Mutex.ReleaseMutex()方法释放这个对象，而在此期间，其他想要获取这个Mutex对象的线程都只有等待。

下面这个例子使用了Mutex对象来同步四个线程，主线程等待四个线程的结束，而这四个线程的运行又是与两个Mutex对象相关联的。

其中还用到AutoResetEvent类的对象，可以把它理解为一个信号灯。这里用它的有信号状态来表示一个线程的结束。
// AutoResetEvent.Set()方法设置它为有信号状态
// AutoResetEvent.Reset()方法设置它为无信号状态

示例程序：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading;

//互斥对象

namespace Ex4

{

    class Program

    {

        static Mutex gM1;

        static Mutex gM2;

        const int ITERS = 100;

        static AutoResetEvent Event1 = new AutoResetEvent(false);

        static AutoResetEvent Event2 = new AutoResetEvent(false);

        static AutoResetEvent Event3 = new AutoResetEvent(false);

        static AutoResetEvent Event4 = new AutoResetEvent(false);

         

        static void Main(string[] args)

        {

            Console.WriteLine("Mutex Sample ...");

            //创建一个Mutex对象，并且命名为MyMutex

            gM1 = new Mutex(true, "MyMutex");

            //创建一个未命名的Mutex对象

            gM2 = new Mutex(true);

            Console.WriteLine("-Main Owns gM1 and gM2");

            AutoResetEvent[] evs = new AutoResetEvent[4];

            evs[0] = Event1;     //为后面线程t1,t2,t3,t4定义AutoResetEvent对象

            evs[1] = Event2;

            evs[2] = Event3;

            evs[3] = Event4;

            Program tm = new Program();

            Thread t1 = new Thread(new ThreadStart(tm.t1Start));

            Thread t2 = new Thread(new ThreadStart(tm.t2Start));

            Thread t3 = new Thread(new ThreadStart(tm.t3Start));

            Thread t4 = new Thread(new ThreadStart(tm.t4Start));

            t1.Start(); //

            t2.Start();

            t3.Start(); //

            t4.Start(); //

            Console.WriteLine("Main Sleep(2000)");

            Thread.Sleep(2000);

            Console.WriteLine("-Main release gM1");

            gM1.ReleaseMutex(); //线程t2,t3结束条件满足

            Thread.Sleep(1000);

            Console.WriteLine("-Main release gM2");

            gM2.ReleaseMutex(); //线程t1,t4结束条件满足

            //等待所有四个线程结束

            WaitHandle.WaitAll(evs);

            Console.WriteLine("... Mutex Sample");

            Console.ReadKey();

        }

        public void t1Start()

        {

            Console.WriteLine("t1Start started, Mutex.WaitAll(Mutex[])");

            Mutex[] gMs = new Mutex[2];

            gMs[0] = gM1;       //创建一个Mutex数组作为Mutex.WaitAll()方法的参数

            gMs[1] = gM2;

            Mutex.WaitAll(gMs); //等待gM1和gM2都被释放

            Thread.Sleep(2000);

            Console.WriteLine("t1Start finished, Mutex.WaitAll(Mutex[]) satisfied");

            gM1.ReleaseMutex();

            gM2.ReleaseMutex();

            Event1.Set();       //线程结束，将Event1设置为有信号状态

        }

          public void t2Start()

        {

            Console.WriteLine("t2Start started, gM1.WaitOne()");

            gM1.WaitOne();       //等待gM1的释放

            Console.WriteLine("t2Start finished, gM1.WaitOne() satisfied");

            gM1.ReleaseMutex();

            Event2.Set();       //线程结束，将Event2设置为有信号状态

        }

          public void t3Start()

        {

            Console.WriteLine("t3Start started, Mutex.WaitAny(Mutex[])");

            Mutex[] gMs = new Mutex[2];

            gMs[0] = gM1;       //创建一个Mutex数组作为Mutex.WaitAny()方法的参数

            gMs[1] = gM1;

            int x = Mutex.WaitAny(gMs);

            Thread.Sleep(2000);

            Console.WriteLine("t3Start finished, Mutex.WaitAny(Mutex[]) satisfied");

            gMs[x].ReleaseMutex();

            Event3.Set();       //线程结束，将Event3设置为有信号状态

        }

          public void t4Start()

          {

              Console.WriteLine("t4Start started, gM2.WaitOne()");

              gM2.WaitOne();       //等待gM1的释放

              Console.WriteLine("t4Start finished, gM2.WaitOne() satisfied");

              gM2.ReleaseMutex();

              Event4.Set();       //线程结束，将Event2设置为有信号状态

          }

    }

}