多线程编程 入门

1. 多线程概述

进程和线程都是操作系统的概念，进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其他各种系统资源组成，进程在运行过程中创建的资源随着进程的终止而被销毁，所使用的系统资源在进程终止时被释放或关闭。
线程是进程内部的一个执行单元。系统创建好进程后，实际上就启动执行了该进程的主执行线程，主执行线程以函数地址形式，比如说main函数，将程序的启动点提供给windows系统，主执行线程终止了，进程也随之终止。
每一个进程至少有一个主执行线程，它无需由用户去主动创建，是由系统自动创建的。用户根据需要在应用程序中创建其他线程，多个线程并发地运行于同一个进程中。一个进程中的所有线程都在该进程的虚拟地址空间中，共同使用这些虚拟地址空间、全局变量和系统资源，所以线程间的通讯非常方便，多线程的应用也很广泛。
多线程可以实现并行处理，避免了某项任务长时间占用CPU时间。要说明的一点是，目前大多数的计算机都是单处理器（CPU）的，为了运行所有的这些线程，操作系统为每个独立线程安排一些CPU时间，操作系统以轮换方式向线程提供时间片，这就给人一种假象，好像这些线程在同时运行。由此可见，两个非常活跃的线程为了抢夺对CPU的控制权，在线程切换时会消耗很多的CPU资源，反而降低系统性能。这一点在多线程编程时应该注意。

2. 多线程

2.1 创建一个线程CreateThread()

1. 函数声明 CreateThread()

//返回值：一个HANDLE类型的值，表示线程的句柄，可用于等待线程等函数
**HANDLE CreateThread(
  LPSECURITY_ATTRIBUTES   lpThreadAttributes, // 不重要，一般设置为NULL
  SIZE_T                  dwStackSize,        // 堆栈大小，不重要，一般设置为0，表示使用默认堆栈大小
  LPTHREAD_START_ROUTINE  lpStartAddress,     // 函数指针，传入函数名或指针即可
  __drv_aliasesMem LPVOID lpParameter,        // 参数指针，供函数使用
  DWORD                   dwCreationFlags,    // 不重要，一般设置为0
  LPDWORD                 lpThreadId          // 指针，用于保存线程的id，一般设置为NULL**
);

2. 使用方法示例

// 声明线程函数的模板：
DWORD WINAPI threadname(LPVOID lpParamter) // 函数名字可随意
{
	/*
	这里填入你的代码
	*/
	return 0L;
}

// 根据声明的函数创造一个线程
// 若函数没有参数，传入函数名字即可，其它参数参考下方示例
 HANDLE hThread = CreateThread(NULL, 0, threadname, NULL, 0, NULL);

实例展示

#include<iostream>
#include<windows.h>

using namespace std;

// 编写了一个我的线程函数
DWORD WINAPI MyThread(LPVOID lpParamter)
{
	cout << "the thread cout  !\n";
	return 0L;
}

int main ()
{
	// 创造线程
	CreateThread(NULL, 0, MyThread, NULL, 0, NULL);
	// 记得等待线程结束
	system("PAUSE");
	return 0;
}

2.2 创建一个带参线程 ：参数 lpParamter

lpParamter 跟 void指针使用方法类似，void指针可以指向任何数据，所以我们可以把任何类形指针的值赋给void指针（但不能把void指针的值直接赋给其它类型的指针！）
假设需要传入一个整形参数，在声明函数时，只需要多一行需要这样的操作：

DWORD WINAPI MyThread(LPVOID lpParamter)
{
	// 把lpParamter当成void指针就完事儿了
	int *a = (int *)lpParamter;
	cout << "I have " << a[0] << " dolors!\n";
	return 0L;
}

而创造函数时候，传入一个整形指针就行了

int main ()
{
	int a = 0;
	int *p = &a;
	// 创造线程，注意我把p指针作为参数传入了，它也就成为了上方函数的lpParamter
	CreateThread(NULL, 0, MyThread, p, 0, NULL);
	// 记得等待线程结束
	system("PAUSE");
	return 0;
}

2.3 等待指定线程结束WaitForSingleObject()

Windows提供了许多内核对象来实现线程的同步。对于线程同步而言，这些内核对象有两个非常重要的状态：“已通知”状态，“未通知”状态（也有翻译为：受信状态，未受信状态）。Windows提供了几种内核对象可以处于已通知状态和未通知状态：进程、线程、作业、文件、控制台输入/输出/错误流、事件、等待定时器、信号量、互斥对象。
你可以通知一个内核对象，使之处于“已通知状态”，然后让其他等待在该内核对象上的线程继续执行。你可以使用Windows提供的API函数，等待函数来等待某一个或某些内核对象变为已通知状态。

你可以使用WaitForSingleObject函数来等待一个内核对象变为已通知状态：

DWORD WaitForSingleObject(
HANDLE hObject,                  //指明一个内核对象的句柄
DWORD dwMilliseconds);            //等待时间

该函数需要传递一个内核对象句柄，该句柄标识一个内核对象，如果该内核对象处于未通知状态，则该函数导致线程进入阻塞状态；如果该内核对象处于已通知状态，则该函数立即返回WAIT_OBJECT_0。第二个参数指明了需要等待的时间（毫秒），可以传递INFINITE指明要无限期等待下去，如果第二个参数为0，那么函数就测试同步对象的状态并立即返回。如果等待超时，该函数返回WAIT_TIMEOUT。如果该函数失败，返回WAIT_FAILED。

还可以使用WaitForMulitpleObjects函数来等待多个内核对象变为已通知状态：

DWORD WaitForMultipleObjects(
DWORD dwCount,                      //等待的内核对象个数
CONST HANDLE* phObjects,            //一个存放被等待的内核对象句柄的数组
BOOL bWaitAll,                      //是否等到所有内核对象为已通知状态后才返回
DWORD dwMilliseconds);              //等待时间

该函数的第一个参数指明等待的内核对象的个数，可以是0到MAXIMUM_WAIT_OBJECTS（64）中的一个值。phObjects参数是一个存放等待的内核对象句柄的数组。bWaitAll参数如果为TRUE，则只有当等待的所有内核对象为已通知状态时函数才返回，如果为FALSE，则只要一个内核对象为已通知状态，则该函数返回。第四个参数和WaitForSingleObject中的dwMilliseconds参数类似。
该函数失败，返回WAIT_FAILED；如果超时，返回WAIT_TIMEOUT；如果bWaitAll参数为TRUE，函数成功则返回WAIT_OBJECT_0，如果bWaitAll为FALSE，函数成功则返回值指明是哪个内核对象收到通知。
使用示例

HANDLE h[3]; //句柄数组

//三个进程句柄
h[0] = hProcess1;
h[1] = hProcess2;
h[2] = hProcess3;

DWORD dw = WaitForMultipleObjects(3, h, FALSE, 5000); //等待3个进程结束

2.4 多线程资源加锁CreateMutex()

当有多个线程同时输出时，就会争相占用输出资源，所以就需要为这个资源加锁，使在一个时间内只能被单个线程使用。
创建方法：

// 声明一个句柄
HANDLE cout_mutex;
// 创建一个锁
cout_mutex = CreateMutex(NULL, FALSE, NULL);

使用方法：

// 等待其它线程释放锁，并获取锁的使用权
WaitForSingleObject(cout_mutex, INFINITE);

// 获取锁之后，只要没有解锁，其它线程就会阻塞在WaitForSingleObject()语句。
做一些工作（使用需要互斥的资源等）

// 解锁！
ReleaseMutex(cout_mutex);

使用实例：

HANDLE cout_mutex;

DWORD WINAPI MyThread(LPVOID lpParamter)
{
	// 把lpParamter当成void指针就完事儿了
	int *a = (int *)lpParamter;
	WaitForSingleObject(cout_mutex, INFINITE);
	cout << "I have " << a[0] << " dolors!" << endl;
	ReleaseMutex(cout_mutex);
	return 0L;
}

int main()
{
	int a[10];
	cout_mutex = CreateMutex(NULL, FALSE, NULL);
	for (int i = 0; i < 10; i++)
	{
		a[i] = i;
		HANDLE hThread = CreateThread(NULL, 0, MyThread, a + i, 0, NULL);
	}
	system("PAUSE");
	return 0;
}

2.5 指定线程运行核心 SetThreadAffinityMask()

现在的cpu一般都是多核的了（任务管理器->性能 -> CPU 即可看到信息），所以有时候需指定线程到某个核心，可以更主动的对cpu资源进行分配。

函数声明

DWORD_PTR SetThreadAffinityMask(HANDLE hThread, DWORD_PTR dwThreadAffinityMask);

第一个参数是线程的句柄（HANDLE），第二个参数用来指定CPU核心

比如，你要指定进程到第0个CPU上，则mask=0×01
第1个CPU：mask=0×02
第2个CPU：mask=0×04 （注意不是0×03）
第3个CPU：mask=0×08
以此类推。
如果要指定多个CPU：
比如第0、1个：mask=0×03
第1、2个：mask=0×06
以此类推。
如果CPU个数不足，则会进行取模操作。比如一共4个CPU，则mask=0×0010则和0×01一样
示例：

// 绑定到第三个核心
HANDLE hThread = CreateThread(NULL, 0, MyThread, a + i, 0, NULL);
SetThreadAffinityMask(hThread, 0x08);