1 并行概念

问题：怎么让1个应用程序中的2个“函数”看起来好像是同时在运行呢？
—— 线程；
问题：怎么让2个“应用程序”看起来好像是在同一个处理器中同时运行呢？
—— 进程；

1.1 虚拟地址空间

虚拟：指的是对于每个应用程序来说，它的地址空间自己看上去好像是无限宽广！

1.1.1 进程的概念

实际上，同一时间，只有1个CPU，只有1个寄存器组！

MMU的作用：将每个应用程序的“虚拟地址”映射到真正的“物理地址”上！通过MMU我们将1个处理器，编程多个“假的处理器”！

1.1.2 线程的概念

多线程的作用：让1个程序里面的多个函数一起跑起来！！！

各个线程以“轮转”的方式平等占用处理器一段时间（这个时间可能是100 ms）。

示例：售票员问题

问题：假设的售票大厅共有10个售票员，150张票，请模拟10个售票员同时售卖150张票的情形！

模拟代码（非并行）：

void SellTickets(int agentID, int numTicketsToSell)
{while(numTicketsToSell > 0) {printf("Agent %d sells a ticket\r\n", agentID),numTicketsToSell--;}printf("Agent %d: All Down\r\n", agentID);
}int main()
{uint8_t agent;int numAgents = 10; // 10个售票员int numTickets = 150; // 150 张票for(agent = 0; agent < numAgents; agent++) {SellTickets(agent, numTickets / numAgents);}return 0;
}

预计结果：160行printf输出！这些票是从第0位售票员开始，依次到第1位售票员、第2位售票员……第9位售票员，1张1张地卖出去的，并不是10个售票员同时售票！！！这样做，10个人弄得跟1个人一样！！！效率太低了！！！

我们肯定希望，10个售票员同时往出买票。

需求：需要寻找1个线程库，来帮助你实现“线程”！

2 windows下的多线程

2.1 C的 <process.h> 与 <windows.h>

<process.h>

序号	函数名	功能
1	_beginthread()	创建1个新线程（简洁版）
2	_endthread()	销毁1个线程（简洁版）
3	_beginthreadex()	创建1个新线程（全面版）
4	_endthreadex()	销毁1个线程（全面版）

<windows.h>

序号	函数名	功能
1	ResumeThread()	恢复线程的运行
2	SuspendThread()	挂起线程
3	GetExiCodeThread()	得到1个线程的退出码
4	WaitForSingleObject()	等待1个对象
5	WaitForMultipleObjects()	等待多个对象

2.1.1 创建线程的方法

<process.h> 中提供了2种创建线程的方式！1个简洁版本的 _beginthread()，这个获取不了子线程的ID号；另1个是全面版本的 _beginthreadex()，这个可以获取子线程的ID号！！！

2.1.1.1 _beginthread() 原型

_CRTIMP uintptr_t __cdecl _beginthread(void (__cdecl *_StartAddress) (void *),unsigned int _StackSize,void *_ArgList);

• 第1个参数 *_StartAddress
  你要执行的函数入口地址（名字）；
• 第2个参数 _StackSize
  分配给这个线程的栈大小，默认0（1MB）；
• 第3个参数 *_ArgList
  传递给线程的参数列表，无参时写NULL；
• 返回值
  成功则返回新线程的句柄，失败则返回0

2.1.1.2 _beginthreadex() 原型

_CRTIMP uintptr_t __cdecl _beginthreadex(void *_Security,unsigned int _StackSize,unsigned int (__stdcall *_StartAddress) (void *),void *_ArgList,unsigned int _InitFlag,unsigned int *_ThrdAddr);

• 第1个参数 *_Security
  安全属性，默认NULL；
• 第2个参数 _StackSize
  分配给这个线程的栈大小，默认0（1MB）；
• 第3个参数 *_StartAddress
  你要执行的函数地址（名字）
• 第4个参数 *_ArgList
  函数入参列表
• 第5个参数 _InitFlag
  新线程的初始状态，0表示立即执行，CREATE_SUSPENDED 表示挂起
• 第6个参数 *_ThrdAddr
  用来传出线程的ID号
• 返回值
  成功则返回新线程的句柄，失败则返回0

示例：运行1个线程

例1：使用简洁的 _beginthread()

typedef struct tag_paramStruct {int param1;int param2;float param3;
} PARAM;void func(void *pParameter)
{PARAM *pMsg = (PARAM *)pParameter;while (1){printf("Hello, I am thread. \r\n");Sleep(1000);printf("I get param 1 is %d\r\n", pMsg->param1);Sleep(500);printf("I get param 2 is %d\r\n", pMsg->param2);Sleep(500);printf("I get param 3 is %f\r\n", pMsg->param3);Sleep(500);}
}int main(int argc, char **argv)
{PARAM pParameter;pParameter.param1 = 5;pParameter.param2 = 10;pParameter.param3 = 3.1415926;_beginthread(func, 0, &pParameter);while (1){printf(">>>>>>>>>> I am main thread\r\n");Sleep(2000);}return 0;
}

例2：使用全面的 _beginthreadex()

// 定义标准的线程函数
unsigned int __stdcall threadFunc(LPVOID param)
{unsigned int *p = (unsigned int *)param;  // dereferencewhile (1){printf("Hello, I am thread %d!\r\n", *p);Sleep(1000);}return 0;
}
// 主线程
int main(int argc, char **argv)
{unsigned int threadId = 0;_beginthreadex(NULL, 0, threadFunc, &threadId, 0, &threadId);while (1){/* code */}return 0;
}

2.1.2 运行线程的方法

2.1.3 挂起线程的方法

2.1.4 销毁线程的方法

2.2 售票员问题的线程级并行实现

2.2.1 相关头文件

#include <stdio.h>
#include "datatype.h"
#include <process.h>
#include <windows.h>
#include <stdlib.h>
#include <time.h>

2.2.2 创建所有线程共有资源（全局变量）

// 定义为全局变量，使得每个线程都能够访问！
#define numAgents 10 // 10个售票员
#define numTickets 150 // 150 张票typedef struct tag_AgentData{unsigned int agentID;unsigned int numTicketsToSell;
}AgentData;// 定义为全局变量，使得每个线程都能够访问！
// 每个售票员必须有自己独立的线程入参、线程id、线程句柄
AgentData pParam[numAgents]; // 每个线程的入参
unsigned int ThreadId[numAgents]; // 每个线程的ID号
HANDLE pHandler[numAgents]; // 每个线程的返回句柄

2.2.3 创建线程中要执行的函数

unsigned int __stdcall SellTickets(LPVOID param)
{AgentData *p = (AgentData *)param;while(p->numTicketsToSell > 0) {printf("Agent %d sells a ticket, %d tickets left\r\n", p->agentID, p->numTicketsToSell);p->numTicketsToSell--;Sleep(rand() % ThreadId[p->agentID] % 3000); // 仿真给每个线程添加“随机的阻塞”！}printf("Agent %d: All Down\r\n", p->agentID);return 0;
}

2.2.4 主线程

int main(int argc, char **argv)
{uint8_t agent; // 用于循环控制uint8_t t = 0;srand(time(NULL));for(agent = 0; agent < numAgents; agent++) {pParam[agent].agentID = agent;pParam[agent].numTicketsToSell = numTickets / numAgents;pHandler[agent] = (HANDLE)_beginthreadex(NULL, 0, SellTickets, &pParam[agent], CREATE_SUSPENDED, &ThreadId[agent]);}for(agent = 0; agent < numAgents; agent++) {ResumeThread(pHandler[agent]);}while (1){printf(">>>>>>>> I am main thread >>>> Time is [%ds] >>>>\r\n", t);Sleep(1000);t++;}return 0;
}

2.3 售票员问题之“信号量”

我们不给每个售票员平均分配相等的票数了！改用每个售票员从1个共有资源地方取票的方法！

2.3.1 windows使用信号量的步骤

步骤	函数	说明
1	CreateSemaphore()	创建1个信号量
2	OpenSemaphore()	打开1个已经存在的信号量
3	WaitForSingleObject()、WaitForMultipleObjects()	等待信号量
4	ReleaseSemaphore()	释放信号量的占有权
5	CloseHandle()	关闭信号量

信号量是这样工作的：

• 等待信号量：等到能用的时候，我就把信号量置0 —— 表示“正在占用”状态！
• 释放信号量：把“信号量” +1 —— 初始值必须>0，也就是释放状态！

信号量的值	说明
0	有人在占用
1	空闲着呢，没人用

2.3.1.1 创建信号量 CreateSemaphore()

WINBASEAPI HANDLE WINAPI CreateSemaphore (LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCWSTR lpName);

• 第1个参数：lpSemaphoreAttributes
  安全属性，如果为NULL则是默认安全属性
• 第2个参数：lInitialCount
  信号量的初始值，要求 >= 0 且 <= lMaximumCount
• 第3个参数：lMaximumCount
  信号量的最大值
• 第4个参数：lpName
  信号量的名字，这是个字符串！可以写NULL，表示产生一个匿名信号量。任何线程（或进程）都可以根据这个“字符串”引用到这个信号量。
• 返回值：HANDLE
  信号量的句柄

2.3.1.2 打开某个信号量 OpenSemaphore()

WINBASEAPI HANDLE WINAPI OpenSemaphore (DWORD dwDesiredAccess, WINBOOL bInheritHandle, LPCSTR lpName);

• 第1个参数：dwDesiredAccess
  表示访问权限，一般传入SEMAPHORE_ALL_ACCESS
• 第2个参数：bInheritHandle
  表示信号量句柄继承性，一般传入TRUE
• 第3个参数：lpName
  信号量的名称，就是CreateSemaphore()时最后那个“字符串”型的名字！

2.3.1.3 等待信号量释放 WaitForSingleObject()

WINBASEAPI DWORD WINAPI WaitForSingleObject (HANDLE hHandle, DWORD dwMilliseconds)

这个函数用于等待信号量的释放！

• 第1个参数：hHandle
  被等待的信号量的句柄，HANDLE类型
• 第2个参数：dwMilliseconds
  等待的时间，单位ms

2.3.1.4 释放信号量 ReleaseSemaphore()

WINBASEAPI WINBOOL WINAPI ReleaseSemaphore (HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount)

• 第1个参数：hSemaphore
  信号量的句柄，HANDLE类型，就是使用CreateSemaphore()的返回值
• 第2个参数：lReleaseCount
  表示信号量值释放的个数，必须大于0且不超过最大资源数，一般为1
• 第3个参数：lpPreviousCount
  这是1个指针，用于传出先前信号量的计数值！

2.3.2 售票员示例代码

#include <stdio.h>
#include "datatype.h"
#include <process.h>
#include <windows.h>
#include <stdlib.h>
#include <time.h>// 定义为全局变量，使得每个线程都能够访问！
#define numAgents 10 // 10个售票员typedef struct tag_AgentData{unsigned int agentID;unsigned int *pNumTickets; // 访问公共资源：票数 numTicketsHANDLE hSemaphore;
}AgentData;// 定义为全局变量，使得每个线程都能够访问！
// 每个售票员必须有自己独立的线程入参、线程id、线程句柄
AgentData pParam[numAgents]; // 每个线程的入参
unsigned int ThreadId[numAgents]; // 每个线程的ID号
HANDLE pHandler[numAgents]; // 每个线程的返回句柄HANDLE gThreadSema;  //创建内核对象，用来初始化信号量unsigned int __stdcall SellTickets(LPVOID param)
{AgentData *p = (AgentData *)param;printf("There are %d tikets\r\n", *p->pNumTickets);while(1) {Sleep(rand() % ThreadId[p->agentID] % 1000); // 仿真售票员在查票！WaitForSingleObject(gThreadSema, INFINITE); // 等待信号量if(*p->pNumTickets == 0) {printf("No tickets!\r\n");break;};*(p->pNumTickets) -= 1;printf("Agent %d sells a ticket, %d tickets left\r\n",p->agentID, *p->pNumTickets);ReleaseSemaphore(p->hSemaphore, 1, NULL); // 信号量的值 + 1Sleep(rand() % ThreadId[p->agentID] % 1000); // 仿真售票员在结账！}ReleaseSemaphore(p->hSemaphore, 1, NULL); // 信号量的值 + 1return 0;
}int main(int argc, char **argv)
{// 公共资源 150张票unsigned int numTickets = 150;uint8_t agent; // 用于循环控制uint8_t t = 0;srand(time(NULL));gThreadSema = CreateSemaphore(NULL, 1, 1, NULL);for(agent = 0; agent < numAgents; agent++) {pParam[agent].agentID = agent;pParam[agent].pNumTickets = &numTickets;pParam[agent].hSemaphore = gThreadSema;pHandler[agent] = (HANDLE)_beginthreadex(NULL, 0, SellTickets, &pParam[agent], CREATE_SUSPENDED, &ThreadId[agent]);}for(agent = 0; agent < numAgents; agent++) {ResumeThread(pHandler[agent]);}while (1){printf(">>>>>>>> I am main thread >>>> Time is [%ds] >>>>\r\n", t);Sleep(1000);t++;}return 0;
}