c++ 多线程 使用CreateThread或std::thread

多线程的功能

线程是进程中的一个实体，是被系统独立调度和分派的基本单位。一个进程可以拥有多个线程，但是一个线程必须有一个进程。线程自己不拥有系统资源，只有运行所必须的一些数据结构，但它可以与同属于一个进程的其它线程共享进程所拥有的全部资源，同一个进程中的多个线程可以并发执行。通过多线程地进行运算，可以更充分地利用CPU资源。

在实践中，多线程有一个不可或缺的功能。如在交互式应用程序中，需要进行持续的数据处理操作，并且实时监听用户的命令。如果单线程执行数据处理，那么在数据处理结束之前，程序是无法接收其他指令的。因此需要为数据处理单独建立一个线程。

CreateThread创建线程函数

参考博客，在C/C++中可以通过CreateThread函数在进程中创建线程，函数的具体格式如下：

HANDLE CreateThread(
                    LPSECURITY_ATTRIBUTES lpThreadAttributes,
                    DWORD dwStackSize,
                    LPTHREAD_START_ROUTINE lpStartAddress,
                    LPVOID lpParameter,
                    DWORD dwCreationFlags,
                    LPDWORD lpThreadID
                   );

参数的含义如下：

lpThreadAttrivutes：指向SECURITY_ATTRIBUTES的指针，用于定义新线程的安全属性，一般设置成NULL；
dwStackSize：分配以字节数表示的线程堆栈的大小，默认值是0；
lpStartAddress：指向一个线程函数地址。每个线程都有自己的线程函数，线程函数是线程具体的执行代码；
lpParameter：传递给线程函数的参数；
dwCreationFlags：表示创建线程的运行状态，其中CREATE_SUSPEND表示挂起当前创建的线程，而0表示立即执行当前创建的进程；
lpThreadID：返回新创建的线程的ID编号；

如果函数调用成功，则返回新线程的句柄

一个实例

//DataProcess.h
#include <Windows.h>
#include <iostream>
class DataProcess
{
public:
	DataProcess(){
		m_nData = 0;
	}
	~DataProcess(){}
	//开始数据处理
	void StartProcess(){
		m_hProcessThread = CreateThread(NULL, 0, ProcessThreadFun, this, 0, &m_dwThreadID);
	}
	//停止数据处理
	void StopProcess() {
		CloseHandle(m_hProcessThread);
	}
	static DWORD WINAPI ProcessThreadFun(LPVOID lpParam){
		if (lpParam != NULL)
		{
			DataProcess* DataProcessPtr = (DataProcess*)lpParam;
			DataProcessPtr->ProcessData();
		}
		return 0;
	}
	//数据处理函数,会持续运行
	void ProcessData()
	{
		while (true)
		{
			Sleep(100);	//模拟数据处理的耗时
			m_nData++;
			std::cout << m_nData << std::endl;
		}
	}
private:
	HANDLE m_hProcessThread;	//数据处理线程句柄
	int m_nData;				//模拟线程处理的数据
	DWORD m_dwThreadID;			//线程ID
};

//main.cpp
#include <Windows.h>
#include <iostream>
#include "DataProcess.h"

int main()
{
	DataProcess *pProcessor = new DataProcess();
	pProcessor->StartProcess();
	Sleep(2000);	//模拟主线程同时进行其他工作
	pProcessor->StopProcess();
	return 0;
}

在这个例子中，我们模拟了一个数据处理类DataProcess，其功能为，连续不断地处理数据。为它单独开辟了一个线程。可以看到，在main函数中，主线程Sleep(2000)，并不影响在DataProcess中进行了20轮的数据处理操作。

std::mutex为线程加锁

参考博客。

std::mutex 是C++11 中最基本的互斥量，std::mutex 对象提供了独占所有权的特性——即不支持递归地对 std::mutex 对象上锁，而 std::recursive_lock 则可以递归地对互斥量对象上锁。

std::mutex 的成员函数

• 构造函数，std::mutex不允许拷贝构造，也不允许 move 拷贝，最初产生的 mutex 对象是处于 unlocked 状态的。
• lock()，调用线程将锁住该互斥量。线程调用该函数会发生下面 3 种情况：(1). 如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，该线程一直拥有该锁。(2). 如果当前互斥量被其他线程锁住，则当前的调用线程被阻塞住。(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。
• unlock()， 解锁，释放对互斥量的所有权。
• try_lock()，尝试锁住互斥量，如果互斥量被其他线程占有，则当前线程也不会被阻塞。线程调用该函数也会出现下面 3 种情况，(1). 如果当前互斥量没有被其他线程占有，则该线程锁住互斥量，直到该线程调用 unlock 释放互斥量。(2). 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被阻塞掉。(3). 如果当前互斥量被当前调用线程锁住，则会产生死锁(deadlock)。

在之前的程序里测试一下mutex的效果:

//main.cpp
#include <Windows.h>
#include <iostream>
#include "DataProcess.h"

int main()
{
	DataProcess *pProcessor = new DataProcess();
	pProcessor->StartProcess();
	Sleep(1000);	//模拟主线程同时进行其他工作
	pProcessor->SetData(-200);
	Sleep(500);
	pProcessor->StopProcess();
	return 0;
}

//DataProcess.h
#include <Windows.h>
#include <mutex>
#include <iostream>
class DataProcess
{
public:
	DataProcess(){
		m_nData = 0;
	}
	~DataProcess(){}
	//开始数据处理
	void StartProcess(){
		m_hProcessThread = CreateThread(NULL, 0, ProcessThreadFun, this, 0, &m_dwThreadID);
	}
	//停止数据处理
	void StopProcess() {
		CloseHandle(m_hProcessThread);
	}
	static DWORD WINAPI ProcessThreadFun(LPVOID lpParam){
		if (lpParam != NULL)
		{
			DataProcess* DataProcessPtr = (DataProcess*)lpParam;
			DataProcessPtr->ProcessData();
		}
		return 0;
	}
	//数据处理函数,会持续运行
	void ProcessData()
	{
		while (true)
		{
			m_ProcessMutex.lock();
			Sleep(100);	//模拟数据处理的耗时
			m_nData++;
			std::cout << m_nData << std::endl;
			m_ProcessMutex.unlock();
		}
	}
	void SetData(int nData)
	{
		m_ProcessMutex.lock();
		this->m_nData = nData;
		m_ProcessMutex.unlock();
	}
private:
	HANDLE m_hProcessThread;	//数据处理线程句柄
	int m_nData;				//模拟线程处理的数据
	DWORD m_dwThreadID;			//线程ID
	std::mutex m_ProcessMutex;	//数据处理操作互斥量
};

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200406113446631.pn添加链接描述
g?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xvZ2ljOTE2OQ==,size_16,color_FFFFFF,t_70)
p.s. 每次数据处理的操作时间并不是严格的100ms，程序运行也需要一定的时间，所以输出的数据并不是10个+5个

std::thread

引自C++11 并发指南一(C++11 多线程初探)

C++11 新标准中引入了四个头文件来支持多线程编程，他们分别是<atomic> ,<thread>,<mutex>,<condition_variable>和<future>。

• <atomic>：该头文主要声明了两个类, std::atomic 和 std::atomic_flag，另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。
• <thread>：该头文件主要声明了 std::thread 类，另外 std::this_thread 命名空间也在该头文件中。
• <mutex>：该头文件主要声明了与互斥量(mutex)相关的类，包括 std::mutex 系列类，std::lock_guard, std::unique_lock, 以及其他的类型和函数。
• <condition_variable>：该头文件主要声明了与条件变量相关的类，包括 std::condition_variable 和 std::condition_variable_any。
• <future>：该头文件主要声明了 std::promise, std::package_task 两个 Provider 类，以及 std::future 和 std::shared_future 两个 Future 类，另外还有一些与之相关的类型和函数，std::async() 函数就声明在此头文件中。

thread的简单应用

下面是一个简单的std::thread的例子：

//main.cpp
#include <Windows.h>
#include <iostream>
#include <thread>

void f1()
{
	int i;
	for (i = 0; i < 5; i++)
	{
		std::cout << i << std::endl;
		Sleep(500);
	}
}

int main()
{
	std::thread t(f1); //用函数f1构造线程。不需要传递参数
	t.join();
	return 0;
}

函数参数可以在thread的构造函数中传入，如下所示：

//main.cpp
#include <Windows.h>
#include <iostream>
#include <thread>

std::mutex m;	//全局互斥量mutex，控制进行连续的输出操作

void f1()
{
	int i;
	for (i = 0; i < 5; i++)
	{
		m.lock();
		std::cout << i << std::endl;
		m.unlock();
		Sleep(500);
	}
}

void f3(int n1, int n2)
{
	int i;
	for (i = 0; i < 5; i++)
	{
		m.lock();
		std::cout << n1 + n2 + i << std::endl;
		m.unlock();
		Sleep(200);
	}
}

int main()
{
	std::thread t1(f1); //用函数f1构造线程。不需要传递参数
	std::thread t3(f3, 5, 7);	//用函数f3构造线程，传递函数所需的两个参数
	t1.join();		//t1线程开始运行
	t3.join();		//t3线程开始运行
	return 0;
}

类中的使用

c++11没有线程强制退出的接口，所以只能自己实现退出逻辑。博客提供了一种实现。

这种实现方法，涉及c++11的atomic类：

头文件：原子类型是封装了一个值的类型，它的访问保证不会导致数据的竞争，并且可以用于在不同的线程之间同步内存访问。

使用atomic可以实现控制线程函数的进行或结束。
线程函数，通过while循环来持续运行。while循环为真的条件中，加入atomic标志位，即可实现在线程函数之外，控制线程的持续与否。

这里是引用
join：join的作用是让主线程等待直到该子线程执行结束
detach: Detach 线程。 将当前线程对象所代表的执行实例与该线程对象分离，使得线程的执行可以单独进行。一旦线程执行完毕，它所分配的资源将会被释放。

join()和detach()的区别在于，join()等待子线程执行完后，再继续主线程。而detach()使得子线程可以单独执行，不影响主线程的继续执行。这种做法存在风险，因为主线程执行完毕后，thread对象析构，就失去了对于线程的控制。程序员需要自行控制子线程何时终止。

下面提供了一个实例：

//DataProcessor.h
#pragma once
#include <Windows.h>
#include <thread>
#include <mutex>
#include <atomic>
using namespace std;

class DataProcessor
{
public:
	DataProcessor() {
		m_bWorking = false;
		m_nData = 0;
	}
	~DataProcessor() {}
	//开始数据处理
	void StartProcess();
	//停止数据处理
	void StopProcess();
	//数据处理函数,会持续运行
	void ProcessData();
	void SetData(int nData);
	
private:
	int m_nData;					//模拟线程处理的数据
	thread m_tProcessThread;		//数据处理线程
	atomic<bool> m_bWorking;		//指示函数是否继续运行
	std::mutex m_ProcessMutex;		//数据处理操作互斥量
};

//DataProcessor.cpp
#include "DataProcessor.h"
#include <functional>
#include <iostream>

void DataProcessor::StartProcess()
{
	m_bWorking = true;
	m_tProcessThread = thread(bind(&DataProcessor::ProcessData, this));	//绑定线程函数
	m_tProcessThread.detach();		//和线程对象分离的，这样线程可以独立地执行
}

void DataProcessor::StopProcess()
{
	m_bWorking = false;	//指示ProcessData()函数退出循环
}

void DataProcessor::ProcessData()
{
	while (m_bWorking)
	{
		m_ProcessMutex.lock();
		Sleep(100);	//模拟数据处理的耗时
		m_nData++;
		std::cout << "processing" << m_nData << std::endl;
		m_ProcessMutex.unlock();
	}
}

void DataProcessor::SetData(int nData)
{
	m_ProcessMutex.lock();
	this->m_nData = nData;
	m_ProcessMutex.unlock();
}

int main()
{
	DataProcessor *pProcessor = new DataProcessor();
	pProcessor->StartProcess();
	Sleep(1000);	//模拟主线程同时进行其他工作
	pProcessor->SetData(-200);
	Sleep(500);
	pProcessor->StopProcess();
	system("pause");
	return 0;
}