引擎之旅 Chapter.2 线程库
预备知识可参考我整理的博客
- Windows编程之线程:https://www.cnblogs.com/ZhuSenlin/p/16662075.html
- Windows编程之线程同步:https://www.cnblogs.com/ZhuSenlin/p/16663055.html
文章目录
- 代码结构
- 线程同步的实现
-
- 原子函数与关键段
-
- Interlocked家族函数的封装
- 关键段的封装
- 内核对象的同步方式
-
- 代码结构
- SyncKernelObject基类
- SyncTrigger
- SyncTimer
- SyncSemaphore
- SyncMutex
- 线程类的实现
- 结语
代码结构
一个简单的线程库需要实现的功能主要有：
- 创建和结束一个线程
- 设置线程的优先级
- 提供一些线程调度的接口
- 查询线程的状态
- 退出一个线程
- 多线程运行时同步的解决方案
- 线程池（非必要）：多用于网络请求、单一且快速能解决的任务。
利用C++类的生命周期，，我们可以实现一个线程的创建放在构造函数上,结束放在析构函数上。当想要实现一个特殊线程时，就采用继承的方式拓展这个线程类。
- 一个基本的类框架如下
//Thread.h 线程基类
class Thread
{
public:
Thread()
{
//Create a thread
//函数入口为：ThreadMain((void)this);
}
~Thread()
{
//Terminate a thread
}
protected:
//线程执行的纯虚函数，子类重写这个函数来说明线程需要执行的任务
virtual int Run()=0;
private:
//此函数会调用(Thread*)param->Run();
static unsigned _stdcall ThreadMain(void* param);
}
//ThreadSync.h 线程同步的方式
//1.原子操作函数
//2.关键段
//3.事件内核对象
//4.可等待的计时器内核对象
//5.信号量内核对象
//6.互斥量内核对象
线程同步的实现
首先我们要明确的一点是：用户方式的线程同步较为简单且独立，仅作稍微的封装为引擎统一风格的代码即可；而对象内核的同步方式是比较统一的，它们的阻塞与恢复是由等待函数(WaitForSingleObject或WaitForMultipleObjects)来实现的，引起它们其实可以统一为一种类型。
原子函数与关键段
用户方式的线程同步比较简单，Windows API也给的比较清楚，下面是相关的代码展示。
Interlocked家族函数的封装
- 代码
//原子操作：++
//*pValue++
FORCEINLINE void TInterlockedIncrement(unsigned long long* pValue)
{
::InterlockedIncrement(pValue);
//原子操作：--
//*pValue--
FORCEINLINE void TInterlockedDecrement(unsigned long long* pValue)
{
::InterlockedDecrement(pValue);
//原子操作：+=
//*added+=addNum
FORCEINLINE void TInterlockedExchangeAdd(PLONG added, LONG addNum)
{
::InterlockedExchangeAdd(added, addNum);
//原子操作：-=
//*added-=addNum
FORCEINLINE void TInterlockedExchangeSub(PULONG subed, LONG subNum)
{
::InterlockedExchangeSubtract(subed, subNum);
//原子操作：=
//target=lvalue;
FORCEINLINE LONG TInterlockedExchange(PLONG target, LONG value)
{
return ::InterlockedExchange(target, value);
//原子操作：=
//pTarget=&pVal
FORCEINLINE PVOID TInterlockedExchangePointer(PVOID* pTarget, PVOID pVal)
{
return ::InterlockedExchangePointer(pTarget, pVal);
//原子操作：
//if(*pDest==compare)
// *pDest=value;
FORCEINLINE LONG TInterlockedCompareExchange(PLONG pDest, LONG value, LONG compare)
{
return ::InterlockedCompareExchange(pDest, value, compare);
//原子操作：
//if(*pDest==pCompare)
// pDest=&value;
FORCEINLINE PVOID TInterlockedCompareExchangePointer(PVOID* ppDest, PVOID value, PVOIpCompare)
{
//如果ppvDestination和pvCompare相同，则执行ppvDestination=pvExchange，否则不变
return ::InterlockedCompareExchangePointer(ppDest, value, pCompare);
}
其实上面的代码就是将Windows API 修改了函数命名。我个人认为，这种写代码的方式是有益处。因为线程库这一块的代码是较为底层的部分，如果上层直接调用API，一旦遇到了Windows API过时等问题导致的实现方式要修改的情况，你就需要一个项目一个项目的去修改名称，这是不严谨的。代码的底层要尽可能地隐藏代码的实现部分，仅提供功能接口。
- 用例:两个线程同时对一个变量进行++操作
int m_gCount=0; //全局变量
class Thread1 : public Thread
{
//...
virtual int Run()
{
TInterlockedIncrement(&((unsigned long long)m_gCount));
}
}
class Thread2 : public Thread
{
//...
virtual int Run()
{
TInterlockedIncrement(&((unsigned long long)m_gCount));
}
}
关键段的封装
- 代码
//Defines [.h]
//-----------------------------------------------------------------------
class TURBO_CORE_API CriticalSection
{
public:
CriticalSection(); //初始化关键段变量
~CriticalSection(); //删除关键段变量
//挂起式关键段访问：即若有其他线程访问时，则调用处会挂起等待
inline void Lock();
//结束访问关键段
inline void Unlock();
//非挂起式关键段访问
//若有其他线程访问此关键段，则返回FALSE。可以访问则放回TRUE
inline bool TryLock();
private:
CRITICAL_SECTION m_cs;
}
//implement[.cpp]
//-----------------------------------------------------------------------
TurboEngine::Core::CriticalSection::CriticalSection()
{
::InitializeCriticalSection(&m_cs);
}
TurboEngine::Core::CriticalSection::~CriticalSection()
{
::DeleteCriticalSection(&m_cs);
}
inline void TurboEngine::Core::CriticalSection::Lock()
{
::EnterCriticalSection(&m_cs);
}
inline void TurboEngine::Core::CriticalSection::Unlock()
{
::LeaveCriticalSection(&m_cs);
}
inline bool TurboEngine::Core::CriticalSection::TryLock()
{
return ::TryEnterCriticalSection(&m_cs);
}
inline void TurboEngine::Core::CriticalSection::SetSpinCount(DWORD dwSpinCount)
{
::SetCriticalSectionSpinCount(&m_cs, dwSpinCount);
}
- 用例:两个线程同时对一个变量进行++操
CriticalSection m_cs;
int m_gCount=0;
class Thread1 : public Thread
{
//...
virtual int Run()
{
m_cs.Lock(); //若有其他线程访问m_gCount则线程挂起等待
m_gCount++;
m_cs.Unlock();
}
}
class Thread2 : public Thread
{
//...
virtual int Run()
{
if(m_cs.TryLock())
{
m_gCount++;
m_cs.Unlock();
}
}
}
内核对象的同步方式
代码结构
- SyncKernelObject
- SyncTrigger
- SyncTimer
- SyncSemaphore
- SyncMutex
SyncKernelObject基类
基类理所应当的封装了线程同步内核对象所需要的一些变量和函数。我们都知道，对于所有的同步内核对象，实现同步都依赖与Wait函数，因此，我也把Wait函数封装在了父类上。基类的代码如下所示：
//Defines [.h]
//-----------------------------------------------------------------------------------------------------------------------
class TURBO_CORE_API SyncKernelObject
{
public:
//等待得状态
enum WaitState : DWORD
{
Abandoned = WAIT_ABANDONED, //占用此内核对象的线程突然被终止时，其他等待的线程中的其中一个会收到WAIT_ABANDONED
Active = WAIT_OBJECT_0, //等待的对象被触发
TimeOut = WAIT_TIMEOUT, //等待超时
Failded = WAIT_FAILED, //给WaitForSingleObject传入了无效参数
Null = Failded - 1 //占用了一个似乎没有相关值得变量表示句柄为NULL（Failed-1）
};
public:
SyncKernelObject(PSECURITY_ATTRIBUTES psa = NULL, LPCWSTR objName = NULL);
~SyncKernelObject();
public:
//获取内核对象的句柄
inline HANDLE GetHandle() { return m_KernelObjHandle; }
//获取内核对象的名称
inline const LPCWSTR GetName() { return m_Name; }
//获取内核对象的安全性结构体
inline PSECURITY_ATTRIBUTES GetPsa() { return m_psa; }
//(静态函数)多个内核对象的等待函数
inline static DWORD Waits(DWORD objCount, CONST HANDLE* pObjects, BOOL waitAll, DWORDwaitMilliSeconds)
{
return WaitForMultipleObjects(objCount, pObjects, waitAll, waitMilliSeconds);
}
protected:
//自身相关的等待函数
WaitState Wait(DWORD milliSeconds);
protected:
HANDLE m_KernelObjHandle; //内核对象句柄
LPCWSTR m_Name; //内核对象名称，默认为NULL
PSECURITY_ATTRIBUTES m_psa; //安全性相关得结构体，通常为NULL
}
SyncTrigger
事件内核对象。我更愿意称它为触发器、开关。作为一个触发器，它存在激活与非激活两种状态，我们可以利用这种状态灵活的控制线程同步问题。
//Defines [.h]
class TURBO_CORE_API SyncTrigger : public SyncKernelObject
{
public:
SyncTrigger(bool bManual, bool isInitialActive, LPCWSTR objName = NULLPSECURITY_ATTRIBUTES psa = NULL);
~SyncTrigger()
//时间内核对象的等待函数（调用父类的Wait函数）
WaitState CheckWait(DWORD waitMilliSeconds)
//当前是否为激活状态
bool IsTrigger();
//设置当前状态为激活
bool SetActive();
//设置当前状态为未激活
bool SetInactive();
};
- 函数解析：
- SyncTrigger:唯一构造函数。bManual为是否是手动重置，isInitialActive为初始激活的状态。
- CheckWait：常规的内核对象Wait函数
- IsTrigger：等待时间为0的Wait函数，用于获取当前Trigger的触发状态
- SetActive:将Trigger设置为触发状态
- SetInactive：Trigger设置为非触发状态
- 用例
//利用触发器作为线程退出的标记（可以避免强行终止线程的操作）
SyncTrigger m_Trigger(true,false); //手动重置、初始状态为非激活的触发器
//某个线程的入口函数
virtual DWORD WINAPI Run()
{
//若此触发器未激活，则持续循环
while(!m_Trigger.IsTrigger())
{
//TO-DO
}
//退出线程
return 0;
}
//当需要退出该线程时，可以调用如下，线程可跳出执行的循环
m_Trigger.SetActive(); //激活此触发器
SyncTimer
计时器内核对象顾名思义，就是和时间相关的控制器。当SyncTimer的内核对象设置为自动重置时，此计时器可以周期性的设置内核对象为激活状态，这就是SyncTimer的主要功能。类的属性和函数如下所示：
class TURBO_CORE_API SyncTimer : public SyncKernelObject
{
public:
SyncTimer(bool bManual, LPCWSTR objName = NULL, PSECURITY_ATTRIBUTES psa = NULL);
~SyncTimer()
//内核对象的等待函数（调用父类的Wait函数）
WaitState CheckWait(DWORD waitMilliSeconds);
//当前是否为激活状态
bool IsTrigger();
//开始计时器
bool StartTimer(const LARGE_INTEGER* startTime, LONG circleMilliSeconds);
//取消计时器
bool CancelTimer();
};
- 函数简析
- SyncTimer：唯一构造函数。bManual为是否是手动重置
- CheckWait：常规的内核对象Wait函数
- IsTrigger：等待时间为0的Wait函数，用于获取当前Trigger的触发状态
- StartTimer：startTime为起始的事件，具体如何赋值可以参考MSDN文档；circleMilliSeconds为周期触发的时 长（毫秒）。注意：此参数只有在内核对象为自动重置模式才有意义。
- CancelTimer：取消开始的计时器
- 用例
//每秒钟SyncTimer激活一次的程序代码
SyncTimer m_gSyncTimer(false); //自动重置的计时器内核对象
//某个线程的入口函数
virtual DWORD WINAPI Run()
{
//若此触发器未激活，则持续循环
while(!m_Trigger.IsTrigger())
{
//使用计时器
if (m_gSyncTimer.IsTrigger())
cout << "SyncTimer激发一次\n";
}
//退出线程
return 0;
}
//注意startTime的参数如何编写：
LARGE_INTEGER liDueTime;
liDueTime.QuadPart = 0;
m_gSyncTimer.StartTimer(&liDueTime, 1000); //设定计时器为1S钟激活一次
startTime:如果值是正的，代表一个特定的时刻。如果值是负的，代表以100纳秒为单位的相对时间
SyncSemaphore
class TURBO_CORE_API SyncSemaphore : public SyncKernelObject
{
public:
SyncSemaphore(LONG initialCount, LONG maximumCount, LPCWSTR objName = NULLPSECURITY_ATTRIBUTES psa = NULL);
~SyncSemaphore();
//申请使用一个资源(此时的引用计数将会减1)
WaitState Lock(DWORD dwMilliseconds);
//释放一个资源
//releaseCount：释放的数量
//oldResCount：未释放前资源的数量
bool Unlock(DWORD releaseCount = 1, LPLONG oldResCount = NULL);
};
- 函数简析
- SyncSemaphore: 唯一构造函数。initialCount：资源创建后立即占用的数量；maximumCount内核对象管理资源的最大数量
- Lock：申请使用一个资源
- Unlock：释放资源
SyncMutex
//互斥内核对象
//可以理解为内核对象版的关键段
class TURBO_CORE_API SyncMutex : public SyncKernelObject
{
public:
SyncMutex(bool initialOccupied, LPCWSTR objName = NULL, PSECURITY_ATTRIBUTES psa NULL);
~SyncMutex();
//挂起式申请访问（若申请访问的变量被占用时则线程挂起）
void Lock();
//结束访问
bool Unlock();
//非挂起式访问
//若有其他线程访问此关键段，则返回FALSE。可以访问则放回TRUE
bool TryLock(DWORD milliSeconds=0);
};
- 函数简析（略），和关键段功能相同
- 用例
//Run1()和Run2()不会发生访问冲突而引发未知结果
SyncMutex m_gMutex(false);
int m_gSyncCounter1=0;
//某个线程的入口函数
virtual DWORD WINAPI Run1()
{
//若此触发器未激活，则持续循环
while(!m_Trigger.IsTrigger())
{
if (m_gMutex.TryLock())
{
cout << "线程[" << GetThreadId() << "]完成一次累加:[" << m_gSyncCounter1 << "]" << "\n";
m_gMutex.Unlock();
}
}
}
//某个线程的入口函数
virtual DWORD WINAPI Run2()
{
//若此触发器未激活，则持续循环
while(!m_Trigger.IsTrigger())
{
if (m_gMutex.TryLock())
{
cout << "线程[" << GetThreadId() << "]完成一次累加:[" << m_gSyncCounter1 << "]" << "\n";
m_gMutex.Unlock();
}
}
}
线程类的实现
上一节我们讲了线程同步的方式，通过编写的线程同步代码。我们使用多线程的时候可以正确的访问一些公共变量。那么关键的线程类我们该如何实现呢。自己对线程理解如下图所示。
相关基类的定义代码如下：
//引擎线程基类
class TURBO_CORE_API Thread
{
public:
enum class PriorityLevel : int
{
TimeCritical = THREAD_PRIORITY_TIME_CRITICAL,
Highest = THREAD_PRIORITY_HIGHEST,
AboveNormal = THREAD_PRIORITY_ABOVE_NORMAL,
Normal = THREAD_PRIORITY_NORMAL,
BelowNormal = THREAD_PRIORITY_BELOW_NORMAL,
Lowest = THREAD_PRIORITY_LOWEST,
Idle = THREAD_PRIORITY_IDLE
};
enum class ThreadState
{
Initialized,
Running,
Suspend,
Stop,
};
public:
//线程构造函数
//priorityLevel:线程优先级，默认为具体如何是实现，如果说熟悉Windows提供的线程API，我想很快就能实现。那么如何开启一个线程呢。既然上面的基类基本实现了对一个线程创建、销毁、调度的函数。那么每个线程的差异点应该在两个虚函数上。
//定义线程名称的位置
virtual const CHAR* ThreadName() = 0;
//线程入口函数的实现代码放置的位置
virtual DWORD WINAPI Run() = 0;
- 用例：定义一个渲染线程并开启
class RenderThread : public Thread
{
public:
virtual const CHAR* ThreadName()
{
return "RenderThread";
}
protected:
virtual DWORD WINAPI Run()
{
//StartRender
while(!gameStop)
{
RenderOpaque();
RenderTransparent();
//...
}
}
}
//开启渲染线程
RenderThread m_gRenderThread;
m_gRenderThread.Start();
结语
上面的线程类和线程同步类共同构成了引擎简单的线程库。当然，真正可用的游戏引擎，其线程库不可能这么简单，但是，对于目前而言，这也足够使用。
碍于篇幅，很多代码仅提供了类的定义，关于类的实现，请参考Github上的项目。