2.一般方法
 一般解决这个问题的办法是使用void*指针来存储数据，象下面的代码：
 map<string,void*>
 但是这样带来几个问题：
 （1）因为C++在不知道类类型时无法正确的释放内存；
 （2）很多使用者使用它时，释放内存的时机难于确定；

3.让它正确释放内存
 我们可以定义一个公共的基类，让所有需要放到容器的类型继承它
 class Object
 {
 public:
  virtual ~Object(){cout<<"Object Destroy" << endl;}
 };
 由于使用了virtual析构函数因此可以确保delete obj的时可以正常工作。因此上面的容器定义变成了这样：
 map<string,Object*>

4.让它知道何时释放内存
 大家都知道，这时必须使用引用计数，不过很幸运有现成的，我们使用boost::share_ptr
 map<string,boost::share_ptr<Object*> >
 很好两个问题都已经解决，但如何向他们中加入C++的基本类型呢？

5.开发基本类型的封装类
 基本类型很多，如果每一个都写一个类，太累了，我们可以定义一个模板，这里的难点是基本类型之间的操作符重载，不同类型之间的运算返回的类型并不相同，这就需要写很多重载函数，在这里我们使用Loki来简化这些操作。使用Loki的TypeList来自动计算应该是什么返回值
 #include"Typelist.h" //Loki头文件
 template <typename T>
 class PrimerType:public Object
 {
 public:
  typedef T value_type;//基本类型
  typedef PrimerType<T> class_type;//基本类型的对象类型
 
 public:
  PrimerType()
   :m_value((value_type)0)
  {
  }
 
  template<typename Other>
   PrimerType(const Other& value)
   :m_value(value)
  {
  }
 
  ~PrimerType()
  {
   cout<<"PrimerType Destroy" << endl;
  }
 
  //基本类型转换操作符重载
  operator value_type() const
  {
   return m_value;
  }
 
  //赋值操作符重载
  const class_type& operator=(value_type value)
  {
   m_value=value;
   return *this;
  }
 
  bool operator!( ) const
  {
   return !m_value;
  }
 
  //作为类成员的算术运算符操作符重载
  class_type& operator++()
  {// ++ 前缀
   m_value+=1;
   return *this;
  }
  const class_type operator++(int)
  {// ++ 后缀
   class_type oldValue=*this;
   m_value+=1;
   return oldValue;
  }
  class_type& operator--()
  {// -- 前缀
   m_value-=1;
   return *this;
  }
  const class_type operator--(int)
  {// -- 后缀
   class_type oldValue=*this;
   m_value-=1;
   return oldValue;
  }
 
  class_type& operator+=(const value_type& value)
  {
   m_value+=value;
   return *this;
  }
  //。。。省略-= /= *= &= |= ^= %= 等等
 private:
  value_type m_value;
  friend istream& operator>><T> ( istream& is, class_type& ptvalue );
 };
 
 //流输入函数，不用输出（通过类型操作符重载自动完成）
 template<typename T>
 istream& operator>> ( istream& is, PrimerType<T>& ptvalue )
 {
  is >> ptvalue.m_value;
  return is;
 }
 //基本类型重定义
 typedef __int8  int8;
 typedef __int16 int16;
 typedef __int32 int32;
 typedef __int64 int64;
 typedef unsigned __int8 uint8;
 typedef unsigned __int16 uint16;
 typedef unsigned __int32 uint32;
 typedef unsigned __int64 uint64;
 
 
 //基本类型的对象类型
 typedef PrimerType<bool>   Boolean;
 typedef PrimerType<int8>   Int8;
 typedef PrimerType<int16>   Int16;
 typedef PrimerType<int32>   Int32;
 typedef PrimerType<int64>   Int64;
 typedef PrimerType<uint8>   UInt8;
 typedef PrimerType<uint16>   UInt16;
 typedef PrimerType<uint32>   UInt32;
 typedef PrimerType<uint64>   UInt64;
 typedef PrimerType<float>   Float;
 typedef PrimerType<double>   Double;
 typedef PrimerType<long>   Long;
 typedef PrimerType<unsigned long> ULong;
 //更友好的名字
 typedef Int8     Char;
 typedef Int16     Short;
 typedef Int32     Int;
 typedef UInt8     Byte;
 typedef UInt16     UShort;
 typedef UInt32     UInt;
 
 //算术运算返回类型的traits，运算时以排在后面的类型返回
 #define  PRIMERTYPELIST TYPELIST_13(bool,int8,uint8,int16,uint16,int32,uint32,long,unsigned long,int64,uint64,float,double)
 //                 |
 //                 int
 template <typename T1, typename T2>
 struct ResultType_Traits
 {
  enum { lefttype_index =::Loki::TL::IndexOf<PRIMERTYPELIST,T1>::value};
  enum { righttype_index =::Loki::TL::IndexOf<PRIMERTYPELIST,T2>::value};
  enum { resulttype_index = (lefttype_index>righttype_index)?lefttype_index:righttype_index};

public void ThreadProc();

Thread thread = new Thread( new ThreadStart( ThreadProc ) );

thread.IsBackground = true;

thread.Start();

但是很多时候，在新的线程中，我们需要与 UI 进行交互，在 .net 中不允许我们直接这样做。可以参考 MSDN 中的描述：

“Windows 窗体”使用单线程单元 (STA) 模型，因为“Windows 窗体”基于本机 Win32 窗口，而 Win32 窗口从本质上而言是单元线程。STA 模型意味着可以在任何线程上创建窗口，但窗口一旦创建后就不能切换线程，并且对它的所有函数调用都必须在其创建线程上发生。除了 Windows 窗体之外，.NET Framework 中的类使用自由线程模型。

STA 模型要求需从控件的非创建线程调用的控件上的任何方法必须被封送到（在其上执行）该控件的创建线程。基类 Control 为此目的提供了若干方法（Invoke、BeginInvoke 和 EndInvoke）。Invoke生成同步方法调用；BeginInvoke生成异步方法调用。

Windows 窗体中的控件被绑定到特定的线程，不具备线程安全性。因此，如果从另一个线程调用控件的方法，那么必须使用控件的一个 Invoke 方法来将调用封送到适当的线程。

正如所看到的，我们必须调用 Invoke 方法，而 BeginInvoke 可以认为是 Invoke 的异步版本。调用方法如下：

public delegate void OutDelegate(string text);

public void OutText(string text)

{

     txt.AppendText(text);

     txt.AppendText( "\t\n" );

}

OutDelegate outdelegate = new OutDelegate( OutText );

this .BeginInvoke(outdelegate, newobject[]{text});

如果我们需要在另外一个线程里面对 UI 进行操作，我们需要一个类似 OutText 的函数，还需要一个该函数的委托 delegate ，当然，这里展示的是自定义的， .net 中还有很多其他类型的委托，可以直接使用，不需要而外声明。例如： MethodInvoker 和 EventHandler ，这两种类型委托的函数外观是固定的， MethodInvoker 是 void Function() 类型的委托，而 EventHandler 是 void Function(object, EventArgs) 类型的委托，第一个不支持参数，第二中的参数类型和数量都是固定的，这两种委托可以很方便的调用，但是缺乏灵活性。请注意 BeginInvoke 前面的对象是 this ，也就是主线程。现在再介绍 Control.InvokeRequired ， Control 是所有控件的基类，对于这个属性 MSDN 的描述是：

获取一个值，该值指示调用方在对控件进行方法调用时是否必须调用 Invoke 方法，因为调用方位于创建控件所在的线程以外的线程中。

该属性可用于确定是否必须调用 Invoke 方法，当不知道什么线程拥有控件时这很有用。

也就是说通过判断 InvokeRequired 可以知道是否需要用委托来调用当前控件的一些方法，如此可以把 OutText 函数修改一下：

public delegate void OutDelegate(string text);

public void OutText(string text)

{

     if( txt.InvokeRequired )

     {

         OutDelegate outdelegate = new OutDelegate( OutText );

         this.BeginInvoke(outdelegate, newobject[]{text});

         return;

     }

     txt.AppendText(text);

     txt.AppendText( "\t\n" );

}

注意，这里的函数没有返回，如果有返回，需要调用 Invoke 或者 EndInvoke 来获得返回的结果，不要因为包装而丢失了返回值。如果调用没有完成， Invoke 和 EndInvoke 都将会引起阻塞。

现在如果我有一个线程函数如下：

public void ThreadProc()

{

     for(int i = 0; i < 5; i++)

     {

         OutText( i.ToString() );

         Thread.Sleep(1000);

     }

}

如果循环的次数很大，或者漏了 Thread.Sleep(1000); ，那么你的 UI 肯定会停止响应，想知道原因吗？看看 BeginInvoke 前面的对象，没错，就是 this ，也就是主线程，当你的主线程不停的调用 OutText 的时候， UI 当然会停止响应。

与以前 VC 中创建一个新的线程需要调用 AfxBeginThread 函数，该函数中第一个参数就是线程函数的地址，而第二个参数是一个类型为 LPVOID 的指针类型，这个参数将传递给线程函数。现在我们没有办法再使用这种方法来传递参数了。我们需要将传递给线程的参数和线程函数包装成一个单独的类，然后在这个类的构造函数中初始化该线程所需的参数，然后再将该实例的线程函数传递给 Thread 类的构造函数。代码大致如下：

public class ProcClass

{

     private string procParameter = "";

     public ProcClass(string parameter)

     {

         procParameter = parameter;

     }

     public void ThreadProc()

     {

     }

}

ProcClass threadProc = new ProcClass("use thread class");

Thread thread = new Thread( new ThreadStart( threadProc.ThreadProc ) );

thread.IsBackground = true;

thread.Start();

就是这样，需要建立一个中间类来传递线程所需的参数。

那么如果我的线程又需要参数，又需要和 UI 进行交互的时候该怎么办呢？可以修改一下代码：

public class ProcClass

{

     private string procParameter = "";

     private Form1.OutDelegate delg = null;

     public ProcClass(string parameter, Form1.OutDelegate delg)

     {

         procParameter = parameter;

         this.delg = delg;

     }

     public void ThreadProc()

     {

         delg.BeginInvoke("use ProcClass.ThreadProc()", null, null);

     }

}

ProcClass threadProc = new ProcClass("use thread class", new OutDelegate(OutText));

Thread thread = new Thread( new ThreadStart( threadProc.ThreadProc ) );

thread.IsBackground = true;

thread.Start();

这里只是我的一些理解，如果有什么错误或者不当的地方，欢迎指出。

public void afunction(object o)

{

// do what ever the function is supposed to do.

}

//thread entry code

{

// create an instance of WaitCallback

WaitCallback myCallback = new WaitCallback (afunction);

//add this to the thread pool / queue a task

ThreadPool.QueueUserWorkItem (myCallback);

}

　　你也可以通过调用ThreadPool.RegisterWaitForSingleObject方法来传递一个System.Threading.WaitHandle,当被通知或者时间超过了调用被System.Threading.WaitOrTimerCallback包装的方法。

　　线程池和基于事件的编程模式使得线程池对注册的WaitHandles的监控和对合适的WaitOrTimerCallback代表方法的调用十分简单(当WaitHandle被释放时)。这些做法其实很简单。这里有一个线程不断的观测在线程池队列等待操作的状态。一旦等待操作完成,一个线程将被执行与其对应的任务。因此,这个方法随着出发触发事件的发生而增加一个线程。

　　让我们看看怎么随事件添加一个线程到线程池,其实很简单。我们只需要创建一个ManualResetEvent类的事件和一个WaitOrTimerCallback的代表,然后我们需要一个携带代表状态的对象,同时我们也要决定休息间隔和执行方式。我们将上面的都添加到线程池,并且激发一个事件:

public void afunction(object o)

{

// do what ever the function is supposed to do.

}


//object that will carry the status information

public class anObject

{

}

//thread entry code

{

//create an event object

ManualResetEvent aevent = new ManualResetEvent (false);


// create an instance of WaitOrTimerCallback

WaitOrTimerCallback thread_method = new WaitOrTimerCallback (afunction);


// create an instance of anObject

anObject myobj = new anObject();


// decide how thread will perform

int timeout_interval = 100; // timeout in milli-seconds.

bool onetime_exec = true;


//add all this to the thread pool.

ThreadPool. RegisterWaitForSingleObject (aevent, thread_method, myobj, timeout_interval, onetime_exec);


// raise the event

aevent.Set();

}

　　在QueueUserWorkItem和RegisterWaitForSingleObject方法中,线程池创建了一个后台的线程来回调。当线程池开始执行一个任务,两个方法都将调用者的堆栈合并到线程池的线程堆栈中。如果需要安全检查将耗费更多的时间和增加系统的负担,因此可以通过使用它们对应的不安全的方法来避免安全检查。就是ThreadPool.UnsafeRegisterWaitForSingleObject 和ThreadPool.UnsafeQueueUserWorkItem。

　　你也可以对与等待操作无关的任务排队。 Timer-queue timers and registered wait operations也使用线程池。它们的返回方法也被放入线程池排队。

　　线程池是非常有用的,被广泛的用于。NET平台上的套节子编程,等待操作注册,进程计时器和异步的I/O。对于小而短的任务,线程池提供的机制也是十分便利处于多线程的。线程池对于完成许多独立的任务而且不需要逐个的设置线程属性是十分便利的。但是,你也应该很清楚,有很多的情况是可以用其他的方法来替代线程池的。比如说你的计划任务或给每个线程特定的属性,或者你需要将线程放入单个线程的空间(而线程池是将所有的线程放入一个多线程空间),抑或是一个特定的任务是很冗长的,这些情况你最好考虑清楚,安全的办法比用线程池应该是你的选择。


System.Threading.Timer Class

　　Timer类对于周期性的在分离的线程执行任务是非常有效的,它不能被继承。

　　这个类尤其用来开发控制台应用程序,因为System.Windows.Forms.Time是不可用的。比如同来备份文件和检查数据库的一致性。

　　当创建Timer对象时,你药估计在第一个代理调用之前等待的时间和后来的每次成功调用之间的时间。一个定时调用发生在方法的应得时间过去,并且在后来周期性的调用这个方法。你可以适应Timer的Change方法来改变这些设置的值或者使Timer失效。当定时器Timer不再使用时,你应该调用Dispose方法来释放其资源。

　　TimerCallback代表负责指定与Timer对象相关联的方法(就是要周期执行的任务)和状态。它在方法应得的时间过去之后调用一次并且周期性的调用这个方法直到调用了Dispose方法释放了Timer的所有资源。系统自动分配分离的线程。

　　让我们来看一段代码看看事如何创建Timer对象和使用它的。我们首先要创建一个TimerCallback代理,在后面的方法中要使用到的。如果需要,下一步我们要创建一个状态对象,它拥有与被代理调用的方法相关联的特定信息。为了使这些简单一些,我们传递一个空参数。我们将实例化一个Timer对象,然后再使用Change方法改变Timer的设置,最后调用Dispose方法释放资源。

// class that will be called by the Timer

public class WorkonTimerReq

{

public void aTimerCallMethod()

{

// does some work

}

}


//timer creation block

{

//instantiating the class that gets called by the Timer.

WorkonTimerReq anObj = new WorkonTimerReq () ;


// callback delegate

TimerCallback tcallback = new TimerCallback(anObj. aTimerCallMethod) ;


// define the dueTime and period

long dTime = 20 ; // wait before the first tick (in ms)

long pTime = 150 ; // timer during subsequent invocations (in ms)


// instantiate the Timer object

Timer atimer = new Timer(tcallback, null, dTime, pTime) ;


// do some thing with the timer object

...

//change the dueTime and period of the Timer

dTime=100;

pTime=300;

atimer.Change(dTime, pTime) ;

// do some thing

...

atimer.Dispose() ;

...

}

异步编程

　　这部分内容如果要讲清楚本来就是很大的一部分,在这里,我不打算详细讨论这个东西,我们只是需要直到它是什么,因为多线程编程如果忽律异步的多线程编程显然是不应该的。异步的多线程编程是你的程序可能会用到的另外一种多线程编程方法。

　　在前面的文章我们花了很大的篇幅来介绍线程的同步和怎么实现线程的同步,但是它有一个固有的致命的缺点,你或许注意到了这一点。那就是每个线程必须作同步调用,也就是等到其他的功能完成,否则就阻塞。当然,某些情况下,对于那些逻辑上相互依赖的任务来说是足够的。异步编程允许更加复杂的灵活性。一个线程可以作异步调用,不需要等待其他的东西。你可以使用这些线程作任何的任务,线程负责获取结果推进运行。这给予了那些需要管理数目巨大的请求而且负担不起请求等待代价的企业级的系统更好的可伸缩性。

　　.NET平台提供了一致的异步编程机制用于ASP.NET,I/O,Web Services,Networking,Message等。


后记

　　由于学习的时候很难找到中文这方面的资料，因此我就只好学习英文的资料，由于水平不高，翻译的时候可能难免曲解原文的意思，希望大家能够指出，同时希望这些东西能够给大家在学习这方面知识给予一定的参考和帮助，那怕是一点点，就很欣慰了。

　　如果对处于阻塞状态的线程调用Thread.Interrupt（）方法将使线程状态改变，但是会抛出ThreadInterupptedException异常，你可以捕获这个异常并且做出处理，也可以忽略这个异常而让运行时终止线程。在一定的等待时间之内，Thread.Interrupt（）和Thread.Abort（）都可以立即唤醒一个线程。

　　下面我们将说明如何从一个线程中止另外一个线程。在这种情况下，我们可以通过使用Thread.Abort（）方法来永久销毁一个线程，而且将抛出ThreadAbortException异常。使终结的线程可以捕获到异常但是很难控制恢复，仅有的办法是调用Thread.ResetAbort（）来取消刚才的调用，而且只有当这个异常是由于被调用线程引起的异常。因此，A线程可以正确的使用Thread.Abort（）方法作用于B线程，但是B线程却不能调用Thread.ResetAbort（）来取消Thread.Abort（）操作。

　　Thread.Abort（）方法使得系统悄悄的销毁了线程而且不通知用户。一旦实施Thread.Abort（）操作，该线程不能被重新启动。调用了这个方法并不是意味着线程立即销毁，因此为了确定线程是否被销毁，我们可以调用Thread.Join（）来确定其销毁，Thread.Join（）是一个阻塞调用，直到线程的确是终止了才返回。但是有可能一个线程调用Thread.Interrupt（）方法来中止另外一个线程，而这个线程正在等待Thread.Join（）调用的返回。

　　尽可能的不要用Suspend()方法来挂起阻塞线程，因为这样很容易造成死锁。假设你挂起了一个线程，而这个线程的资源是其他线程所需要的，会发生什么后果。因此，我们尽可能的给重要性不同的线程以不同的优先级，用Thread.Priority（）方法来代替使用Thread.Suspend（）方法。

　　Thread类有很多的属性，这些重要的属性是我们多线程编程必须得掌握的。

　　Thread.IsAlive属性：获取一个值，该值指示当前线程的执行状态。如果此线程已启动并且尚未正常终止或中止，则为 true；否则为 false。

　　Thread.Name 属性：获取或设置线程的名称。

　　Thread.Priority 属性：获取或设置一个值，该值指示线程的调度优先级。
　　Thread.ThreadState 属性：获取一个值，该值包含当前线程的状态。
　　在下面的例子中，我们将看看怎么设置这些属性，在随后的例子中我们将详细的讨论这些属性。
　　创建一个线程，首先得实例化一个Thread类，在类得构造函数中调用ThreadStart委派。这个委派包含了线程从哪里开始执行。当线程启动后，Start()方法启动一个新的线程。下面是例子程序。

using System;
using System.Threading ;
namespace LearnThreads
{
class Thread_App
{
public static void First_Thread()
{
　Console.WriteLine("First thread created");
　Thread current_thread = Thread.CurrentThread;
　string thread_details = "Thread Name: " + current_thread.Name + "\r\nThread State: " + current_thread.ThreadState.ToString()+"\r\n Thread Priority level:"+current_thread.Priority.ToString();
　Console.WriteLine("The details of the thread are :"+ thread_details);
　Console.WriteLine ("first thread terminated");
}

public static void Main()
{
　ThreadStart thr_start_func = new ThreadStart (First_Thread);
　Console.WriteLine ("Creating the first thread ");
　Thread fThread = new Thread (thr_start_func);
　fThread.Name = "first_thread";
　fThread.Start (); //starting the thread
}
}
}

　　在这个例子中，创建了一个fThread的线程对象，这个线程负责执行First_Thread()方法里面的任务。当Thread的Start() 方法被调用时包含First_Thread()的地址ThreadStart的代理将被执行。

Thread状态
　　System.Threading.Thread.ThreadState属性定义了执行时线程的状态。线程从创建到线程终止，它一定处于其中某一个状态。当线程被创建时，它处在Unstarted状态，Thread类的Start() 方法将使线程状态变为Running状态，线程将一直处于这样的状态，除非我们调用了相应的方法使其挂起、阻塞、销毁或者自然终止。如果线程被挂起，它将处于Suspended状态，除非我们调用resume（）方法使其重新执行，这时候线程将重新变为Running状态。一旦线程被销毁或者终止，线程处于Stopped状态。处于这个状态的线程将不复存在，正如线程开始启动，线程将不可能回到Unstarted状态。线程还有一个Background状态，它表明线程运行在前台还是后台。在一个确定的时间，线程可能处于多个状态。据例子来说，一个线程被调用了Sleep而处于阻塞，而接着另外一个线程调用Abort方法于这个阻塞的线程，这时候线程将同时处于WaitSleepJoin和AbortRequested状态。一旦线程响应转为Sle阻塞或者中止，当销毁时会抛出ThreadAbortException异常。

线程优先级
　　System.Threading.Thread.Priority枚举了线程的优先级别，从而决定了线程能够得到多少CPU时间。高优先级的线程通常会比一般优先级的线程得到更多的CPU时间，如果不止一个高优先级的线程，操作系统将在这些线程之间循环分配CPU时间。低优先级的线程得到的CPU时间相对较少，当这里没有高优先级的线程，操作系统将挑选下一个低优先级 的线程执行。一旦低优先级的线程在执行时遇到了高优先级的线程，它将让出CPU给高优先级的线程。新创建的线程优先级为一般优先级，我们可以设置线程的优先级别的值，如下面所示：

　　Highest
　　AboveNormal
　　Normal
　　BelowNormal
　　Lowest

结论：在这一部分，我们讨论了线程的创建何线程的优先级。System.Threading命名空间还包含了线程锁定、线程同步何通讯、多线程管理类以及死锁解决等等高级特性，在后面的部分我们将继续讨论这些内容。

　　列表A:

　　或许你并不想进行同步调用，因为它被打包发送到另一个线程中去了。你可以通过BeginInvoke()和EndInvoke()方法来实现它。你可以依照通用的.NET非同步编程模式（asynchronous programming model）来使用这些方法：用BeginInvoke()来发送调用，用EndInvoke()来实现等待或用于在完成时进行提示以及收集返回结果。

　　还值得一提的是ISynchronizeInvoke方法并非安全类型。 类型不符会导致在执行时被抛出异常，而不是编译错误。所以在使用ISynchronizeInvoke时要格外注意，因为编辑器无法检查出执行错误。

　　实现ISynchronizeInvoke要求你使用一个代理来在后期绑定（late binding）中动态地调用方法。每一种代理类型均提供DynamicInvoke()方法： public object DynamicInvoke(object[]
args);

　　理论上来说，你必须将一个方法代理放到一个需要提供对象运行的真实的线程中去，并使Invoke() 和BeginInvoke()方法中的代理中调用DynamicInvoke()方法。ISynchronizeInvoke的实现是一个非同一般的编程技巧，本文附带的源文件中包含了一个名为Synchronizer的帮助类（helper class）和一个测试程序，这个测试程序是用来论证列表A中的Calculator类是如何用Synchronizer类来实现ISynchronizeInvoke的。Synchronizer是ISynchronizeInvoke的一个普通实现，你可以使用它的派生类或者将其本身作为一个对象来使用，并将ISynchronizeInvoke实现指派给它。

　　用来实现Synchronizer的一个重要元素是使用一个名为WorkerThread的嵌套类（nested class）。WorkerThread中有一个工作项目（work item）查询。WorkItem类中包含方法代理和参数。Invoke()和BeginInvoke()用来将一个工作项目实例加入到查询里。WorkerThread新建一个.NET worker线程，它负责监测工作项目的查询任务。查询到项目之后，worker会读取它们，然后调用DynamicInvoke()方法。