写这篇博客之前，由于对多线程也不是很了解，一直觉得多线程是个很神奇的东西，但项目中又需要用到，所以借此机会学习了一下，也算做个入门总结吧，写下来总是好的！言归正传，首先介绍几个多线程相关的基本概念：
并发、并行、同步、异步、多线程的区别
1、并发：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种并发关系分别是同步和互斥。
2、并行：在单处理器中多道程序设计系统中，进程被交替执行，表现出一种并发的外部特征；在多处理器系统中，进程不仅可以交替执行，而且可以重叠执行。在多处理器上的程序才可实现并行处理。从而可知，并行是针对多处理器而言的。并行是同时发生的多个并发事件，具有并发的含义，但并发不一定并行，也亦是说并发事件之间不一定要同一时刻发生。
3、互斥：进程间相互排斥的使用临界资源的现象，就叫互斥。
4、同步：进程之间的关系不是相互排斥临界资源的关系，而是相互依赖的关系。进一步的说明：就是前一个进程的输出作为后一个进程的输入，当第一个进程没有输出时第二个进程必须等待。具有同步关系的一组并发进程相互发送的信息称为消息或事件。
其中并发又有伪并发和真并发，伪并发是指单核处理器的并发，真并发是指多核处理器的并发。
5、异步：异步和同步是相对的，同步就是顺序执行，执行完一个再执行下一个，需要等待、协调运行。异步就是彼此独立,在等待某事件的过程中继续做自己的事，不需要等待这一事件完成后再工作。线程就是实现异步的一个方式。异步是让调用方法的主线程不需要同步等待另一线程的完成，从而可以让主线程干其它的事情。
6、多线程：多线程是程序设计的逻辑层概念，它是进程中并发运行的一段代码。多线程可以实现线程间的切换执行。
异步和多线程并不是一个同等关系,异步是最终目的,多线程只是我们实现异步的一种手段。异步是当一个调用请求发送给被调用者,而调用者不用等待其结果的返回而可以做其它的事情。实现异步可以采用多线程技术或者交给另外的进程来处理。
为了对以上概念的更好理解举一个简单例子：假设我要做 烧开水，举杠铃100下， 洗衣服 3件事情。
（a）烧开水 这件事情，我要做的事情为：
准备烧开水 1分钟，
等开水烧开 8分钟 ，
关掉烧水机 1分钟
（b）举杠铃100下，我要做的事情为：
举杠铃100下 10分钟，
（c）洗衣服这件事，我要做的事情为：
准备洗衣服 1分钟，
等开水烧开 5分钟 ，
关掉洗衣机 1分钟
（一）单核情况下：
（1）同步的完成，我需要做的时间为 1+ 8 +1 + 10 +1+ 5 +1 = 27 分钟；
（2）如果异步，就是在等的时候，我可以切换去做别的事情：
准备烧开水 1分钟+ 准备洗衣服 1分钟+ 举50下杠铃 5分钟+关洗衣机 1分钟 + 举杠铃20下 2分钟+关烧水机 1分钟 + 举30下杠铃 3分钟；
1+1+5+1+2+1+3 =14 分钟；
（二）双核
（1）异步、并行：
核1 准备烧开水 1分钟+举杠铃50下(5)分钟+等待3分钟 + 关掉烧水机 1分钟；
核2 准备洗衣服 1分钟+举杠铃50下(5)分钟+关掉洗衣机 1分钟 + 等待3分钟；
其实只花了 1+5+3+1 = 10分钟，其中还有双核都等待了3分钟；
（2）异步、非并行：
核1 举杠铃100下(10)分钟；
核2 准备烧开水 1分钟+准备洗衣服 1分钟+等待5分钟++ 关掉烧水机 1分钟 +等待 1 分钟 + 关掉洗衣机 1分钟；
其实只花了 1+5+3+1 = 10分钟；
那么以单核为例，下面看看多线程的做法：
线程1 准备烧开水 1分钟， 等开水烧开 8分钟 , 关掉烧水机 1分钟；
线程2 举杠铃100下 10分钟；
线程3 准备洗衣服 1分钟， 等开水烧开 5分钟 , 关掉洗衣机 1分钟；
CPU可能这么切换 最理想的切换方式：
线程1 准备烧开水（1分钟） sleep（1分钟） sleep（5分钟） sleep （1分钟） sleep （2分钟） 关开水（1分钟） exit；
线程2 sleep （1分钟） sleep（1分钟） 举杠铃50下（5分钟） sleep （1分钟） 举杠铃20下（2分钟） sleep（1分钟） 举杠铃30下（3分钟） exit；
线程3 sleep（1分钟） 准备洗衣服（1分钟） sleep（5分钟） 关洗衣机（1分钟） exit；
最后使用了 14分钟 和异步是一样的。但是实际上是不一样的，因为线程不会按照我们设想的去跑， 如果线程2 举杠铃先跑，整个流程的速度就下来了。
异步和同步的区别：在IO等待的时候，同步不会切走，浪费了时间。如果都是独占CPU的业务， 比如举杠铃的业务，在单核情况下 多线程和单线程没有区别。
多线程的好处：比较容易的实现了 异步切换的思想， 因为异步的程序很难写的。多线程本身程还是以同步完成，但是应该说比效率是比不上异步的。 而且多线很容易写，相对效率也高。
多核的好处，就是可以同时做事情， 这个和单核完全不一样的。
线程状态：
在一个线程的生存期内，可以在多种状态之间转换。不同操作系统可以实现不同的线程模型，定义许多不同的线程状态，每个状态还可以包含多个子状态。但大体说来，如下几种状态是通用的：
就绪：参与调度，等待被执行。一旦被调度选中，立即开始执行。
运行：占用CPU，正在运行中。
休眠：暂不参与调度，等待特定事件发生。
中止：已经运行完毕，等待回收线程资源。
线程环境：
线程存在于进程之中。进程内所有全局资源对于内部每个线程均是可见的。
进程内典型全局资源有如下几种：
代码区。这意味着当前进程空间内所有可见的函数代码，对于每个线程来说也是可见的。
静态存储区。全局变量。静态变量。
动态存储区。也就是堆空间。
线程内典型的局部资源有：
本地栈空间。存放本线程的函数调用栈，函数内部的局部变量等。
部分寄存器变量。例如本线程下一步要执行代码的指针偏移量。
一个进程发起之后，会首先生成一个缺省的线程，通常称这个线程为主线程。C/C++程序中主线程就是通过main函数进入的线程。由主线程衍生的线程称为从线程，从线程也可以有自己的入口函数，作用相当于主线程的main函数。
什么时候该使用多线程呢？这要分四种情况讨论：
a.多核CPU——计算密集型任务。此时要尽量使用多线程，可以提高任务执行效率，例如加密解密，数据压缩解压缩（视频、音频、普通数据），否则只能使一个核心满载，而其他核心闲置。
b.单核CPU——计算密集型任务。此时的任务已经把CPU资源100%消耗了，就没必要也不可能使用多线程来提高计算效率了；相反，如果要做人机交互，最好还是要用多线程，避免用户没法对计算机进行操作。
c.单核CPU——IO密集型任务，使用多线程还是为了人机交互方便，
d.多核CPU——IO密集型任务，这就更不用说了，跟单核时候原因一样。
总的来说：当不需要过问它什么时候完成，以及不想让主程序卡住时，就用一个线程，让它慢慢的去执行就行了，或者有很多事情需要同时进行，特别需要效率的时候，比如多线程同时读取数据、下载文件的时候最好使用多线程。
多线程有什么禁忌？
1.不是线程越多越好，一般建议是CPU核数的2倍为佳，但是也可以多一些；系统的多线程总数是有限的，不要无修止的开新线程，不然系统资源会很快被用完的；
2.多个线程之间需要共用数据的时候，要注意同步的问题（加锁），经常会死锁，还有不必要的锁；
3.在WEB服务器比如ASP.NET中用多线程有时会出现异常，原因是你在虚拟主机上面使用，而服务端没有给你过大的资源导致无法分配；
4.在桌面程序(winform)中使用多线程时，子线程不要直接操作主线程的控件，不然会莫名的让程序就退出了。
其实C++语言本身并没有提供多线程机制，但Windows系统为我们提供了相关API，我们可以使用它们来进行多线程编程。那么我们就以实例的形式讲解多线程编程的知识。
（一）创建线程的API函数：
<pre name="code" class="html">HANDLE CreateThread(
__in SEC_ATTRS
SecurityAttributes,
__in ULONG
StackSize, // initial stack size
__in SEC_THREAD_START
StartFunction, // thread function
__in PVOID
ThreadParameter, // thread argument
__in ULONG
CreationFlags, // creation option
__out PULONG
ThreadId // thread identifier
);//在这里我们只用到了第三个和第四个参数，第三个参数传递了一个函数的地址，也是我们要指定的新的线程，第四个参数是传给新线程的参数指针。
多线程编程实例1：
#include <iostream>
#include <windows.h>
using namespace std;
DWORD WINAPI Fun(LPVOID lpParamter)
{
while(1) { cout<<"Fun display!"<<endl; }
}
int main()
{
HANDLE hThread = CreateThread(NULL, 0, Fun, NULL, 0, NULL);
CloseHandle(hThread);
while(1) { cout<<"main display!"<<endl; }
return 0;
}
//我们可以看到主线程（main函数）和我们自己的线程（Fun函数）是随机地交替执行的，但是两个线程输出太快，使我们很难看清楚，我们可以使用函数Sleep来暂停线程的执行。
VOID WINAPI Sleep(
__in DWORD dwMilliseconds
);
//dwMilliseconds表示千分之一秒，所以 Sleep(1000); 表示暂停1秒。
多线程编程实例2：
#include <iostream>
#include <windows.h>
using namespace std;
DWORD WINAPI Fun(LPVOID lpParamter)
{
while(1) { cout<<"Fun display!"<<endl; Sleep(1000);}
}
int main()
{
HANDLE hThread = CreateThread(NULL, 0, Fun, NULL, 0, NULL);
CloseHandle(hThread);
while(1) { cout<<"main display!"<<endl; Sleep(2000);}
return 0;
}
执行上述代码，这次我们可以清楚地看到在屏幕上交错地输出Fun display!和main display!，我们发现这两个函数确实是并发运行的，细心的读者可能会发现我们的程序是每当Fun函数和main函数输出内容后就会输出换行，但是我们看到的确是有的时候程序输出换行了，有的时候却没有输出换行，甚至有的时候是输出两个换行。这是怎么回事？下面我们把程序改一下看看。
多线程编程实例3：
#include <iostream>
#include <windows.h>
using namespace std;
DWORD WINAPI Fun(LPVOID lpParamter)
{
while(1) { cout<<"Fun display!\n"; Sleep(1000);}
}
int main()
{
HANDLE hThread = CreateThread(NULL, 0, Fun, NULL, 0, NULL);
CloseHandle(hThread);
while(1) { cout<<"main display!\n"; Sleep(2000);}
return 0;
}
我们再次运行这个程序，我们发现这时候正如我们预期的，正确地输出了我们想要输出的内容并且格式也是正确的。下面我就来讲一下此前我们的程序为什么没有正确的运行。多线程的程序是并发地运行的，多个线程之间如果公用了一些资源的话，我们并不能保证这些资源都能正确地被利用，因为这个时候资源并不是独占的，下面举个例子吧。
假如有一个资源 int a = 3，有一个线程函数 selfAdd() 该函数是使 a += a;
又有一个线程函数 selfSub() 该函数是使 a -= a;
我们假设上面两个线程正在并发运行，如果selfAdd在执行的时候，我们的目的是想让a变成6，但此时selfSub得到了运行的机会，所以a变成了0，等到selfAdd的到执行的机会后，a += a ，但是此时a确是0，并没有如我们所预期的那样的到6。
我们回到前面实例2，在这里，我们可以把屏幕看成是一个资源，这个资源被两个线程所共用，加入当Fun函数输出了Fun display!后，将要输出endl（也就是清空缓冲区并换行，在这里我们可以不用理解什么是缓冲区），但此时main函数确得到了运行的机会，此时Fun函数还没有来得及输出换行就把CPU让给了main函数，而这时main函数就直接在Fun display!后输出main display!，至于为什么有的时候程序会连续输出两个换行，读者可以采用同样的分析方法来分析，在这里我就不多讲了，留给读者自己思考了。
那么为什么我们把实例2改成实例3就可以正确的运行呢？原因在于，多个线程虽然是并发运行的，但是有一些操作是必须一气呵成的，不允许打断的，所以我们看到实例2和实例3的运行结果是不一样的。
那么，是不是实例2的代码我们就不可以让它正确的运行呢？答案当然是否，下面我就来讲一下怎样才能让实例2的代码可以正确运行。这涉及到多线程的同步问题。对于一个资源被多个线程共用会导致程序的混乱，我们的解决方法是只允许一个线程拥有对共享资源的独占，这样就能够解决上面的问题了。
多线程编程实例4：
HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner, // initial owner
LPCTSTR lpName // object name
);
//该函数用于创造一个独占资源，第一个参数我们没有使用，可以设为NULL，第二个参数指定该资源初始是否归属创建它的进程，第三个参数指定资源的名称。
HANDLE hMutex = CreateMutex(NULL,TRUE,"screen");
//这条语句创造了一个名为screen并且归属于创建它的进程的资源。
BOOL ReleaseMutex(
HANDLE hMutex // handle to mutex
);
//该函数用于释放一个独占资源，进程一旦释放该资源，该资源就不再属于它了，如果还要用到，需要重新申请得到该资源。申请资源的函数如下：
DWORD WaitForSingleObject(
HANDLE hHandle, // handle to object
DWORD dwMilliseconds // time-out interval
);
//第一个参数指定所申请的资源的句柄，第二个参数一般指定为INFINITE，表示如果没有申请到资源就一直等待该资源，如果指定为0，表示一旦得不到资源就返回，也可以具体地指定等待多久才返回，单位是千分之一秒。好了，该到我们来解决实例2的问题的时候了，我们可以把实例2做一些修改，如下面的实例。
多线程编程实例5：
#include <iostream>
#include <windows.h>
using namespace std;
HANDLE hMutex;
DWORD WINAPI Fun(LPVOID lpParamter)
{
while(1) {
WaitForSingleObject(hMutex, INFINITE);
cout<<"Fun display!"<<endl;
Sleep(1000);
ReleaseMutex(hMutex);
}
}
int main()
{
HANDLE hThread = CreateThread(NULL, 0, Fun, NULL, 0, NULL);
hMutex = CreateMutex(NULL, FALSE, "screen");
CloseHandle(hThread);
while(1) {
WaitForSingleObject(hMutex, INFINITE);
cout<<"main display!"<<endl;
Sleep(2000);
ReleaseMutex(hMutex);
}
return 0;
}
//运行此代码会得到我们预期的输出内容。
本文至此，如果自己动手改改，试一些例子，会加深对多线程编程的认识。刚开始只要把基本概念弄懂了，后面可以一步一步搭建出很复杂的类。不过刚开始不要贪多，否则欲速则不达，越弄越糊涂。我的学习方法是：抽象理解，具体分析，由浅入深，循序渐进。晚安！