多线程-对于高并发windows服务器开发，如何更好的创建和管理线程？

Question

在多线程开发过程经常会遇到多线程的管理问题，在windows平台怎样才能更好的管理自己的线程？

Answer 1

我認為服務器的開發 高並發是其次，首要的是不崩和不卡，然後是內存的管理，最後才是多線程/進程；再怎麼樣一機器的最大並發數都是有限的，不需要太執著於超高並發，大並發除了程序外，機器的配置（CPU、內存、網卡）、帶寬等都是制約並發數的因素

Answer 2

first，儘量少用線程, second， 線程間的代碼併做好同步工作，防止鎖的氾濫。 last：線程池是一個很好的通用架構。

补充一下，在服务器的设计中，应该尽量避免多线程设计，而使用多进程，这样的好处是，当一个模块出现问题锁死或需自动重启的时候，其他模块还可以工作，这样在运营中能够提升很高的用户体验。很多时候我们看到一个游戏还能打怪，但无法接取任务，就是这样的情况，但5分钟后，进程重启，问题就解决了。若使用多线程，那么一个线程的问题将导致整个进程失效，玩家可能被踢下线或者卡主，体验很不好。

Answer 3

Windows上做开发，估计不使用线程的情况很少很少。要避免界面卡，利用多核CPU的能力，都要用到线程。多线程编程需要注意两方面的问题：

数据的共享
消息的通讯

Answer 4

首先，我想应该先了解一下什么是线程，操作系统里说线程是系统可以管理的最小的单元，线程管理里--操作系统控制着他的CPU使用；而我们抛开系统的概念，线程又是什么呢？线程是一系列可以独立执行的指令的堆栈，我们自己控制着代码的执行，这就是为什么线程函数里都要有一个循环的原因，只不过为了更好的利用硬件的资源，我们引入了系统的概念，而多线程就是多套相互独立的指令堆栈，如果没有系统的管理线程的代码也是可以单独执行的，系统的最重要的工作是保护好线程堆栈的现场。

面向对象的方法让我们很好的管理资源，所有设计到系统内核的资源，我们都有可能忘掉还给系统的时候，这时候就会出现系统资源的浪费，自从OO方法的出现就引入了利用对象来管理资源的方法，微软在MFC已经采用了这样的方法，但微软的方法太臃肿（个人认为i），在.NET平台推出以后更是这样；在LINIUX上也有很多这样的类库的代码。

下面是我个人写的一个类库，利用这个库可以很好的管理线程资源。

/************************************************************************

版权所有 (C)2008, 陈彦旭。
文件名称： MyThread.h
内容摘要： 线程资源管理和使用
其它说明：
当前版本： 1.0.0.0
作 者： 陈彦旭
完成日期： 2008年01月20日

************************************************************************/

#if !defined(AFX_MYTHREAD_H__D97FB306_0742_43F7_8574_581DB0FBE538__INCLUDED_)
#define AFX_MYTHREAD_H__D97FB306_0742_43F7_8574_581DB0FBE538__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// #include <Thread.h>
#include <process.h>

#include "MyMutex.h"

class CMyThread
{
public:
CMyThread();
virtual ~CMyThread();

public:
static DWORD WINAPI ThreadFunc(LPVOID pParam);

public:
virtual BOOL AfterWork();
virtual BOOL Work();
virtual BOOL BeforeWork();
public:
BOOL IsRun();
BOOL IsPause();
BOOL IsSuspend();
BOOL IsExit();
BOOL SetExitState( BOOL bState );
BOOL SetRunState( BOOL bState );
BOOL SetPauseState( BOOL bState );
BOOL SetSuspendState( BOOL bState );
public:
BOOL RunThread();
BOOL StopThread( DWORD dwDelayTime=2000 );

BOOL SuspendThread();
BOOL ResumeThread();

void SetThreadName(CString sThreadName=_T(""));
CString GetThreadName();

HANDLE GetThreadHandle();
DWORD GetThreadID();
BOOL CloseThread();

private:
BOOL m_bRun;
BOOL m_bPause;
BOOL m_bExit;
BOOL m_bSuspend;
CString m_sThreadName;

CMyMutex m_RunMutex;
CMyMutex m_PauseMutex;
CMyMutex m_ExitMutex;
CMyMutex m_SuspendMutex;

HANDLE m_hThread;
DWORD m_dwThreadId;
};

#endif // !defined(AFX_MYTHREAD_H__D97FB306_0742_43F7_8574_581DB0FBE538__INCLUDED_)
// MyThread.cpp: implementation of the CMyThread class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MyThread.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

typedef unsigned (__stdcall *PTHREAD_START) (void *);
#define chBEGINTHREADEX(psa, cbStack, pfnStartAddr, /
pvParam, fdwCreate, pdwThreadID) /
((HANDLE) _beginthreadex( /
(void *) (psa), /
(unsigned) (cbStack), /
(PTHREAD_START) (pfnStartAddr), /
(void *) (pvParam), /
(unsigned) (fdwCreate), /
(unsigned *) (pdwThreadID)))

CMyThread::CMyThread()
{
m_bRun = FALSE;
m_bPause = FALSE;
m_bExit = FALSE;
m_bSuspend = FALSE;

m_sThreadName = _T("");
m_hThread = NULL;
m_dwThreadId = 0;
}

CMyThread::~CMyThread()
{

}

BOOL CMyThread::AfterWork()
{
return TRUE;
}

BOOL CMyThread::Work()
{
return TRUE;
}

BOOL CMyThread::BeforeWork()
{
return TRUE;
}

BOOL CMyThread::IsRun()
{
CUseMutex mutex(&this->m_RunMutex);
return this->m_bRun;
}

BOOL CMyThread::IsPause()
{
CUseMutex mutex(&this->m_PauseMutex);
return this->m_bPause;
}

BOOL CMyThread::IsSuspend()
{
CUseMutex mutex(&this->m_SuspendMutex);
return this->m_bSuspend;
}

BOOL CMyThread::IsExit()
{
CUseMutex mutex(&this->m_ExitMutex);
return this->m_bExit;
}

BOOL CMyThread::SetExitState( BOOL bState )
{
CUseMutex mutex(&this->m_ExitMutex);
this->m_bExit = bState;
return TRUE;
}

BOOL CMyThread::SetRunState( BOOL bState )
{
CUseMutex mutex(&this->m_RunMutex);
this->m_bRun = bState;
return TRUE;
}

BOOL CMyThread::SetPauseState( BOOL bState )
{
CUseMutex mutex(&this->m_PauseMutex);
this->m_bPause = bState;
return TRUE;
}
BOOL CMyThread::SetSuspendState( BOOL bState )
{
CUseMutex mutex(&this->m_SuspendMutex);
this->m_bSuspend = bState;
return TRUE;
}

BOOL CMyThread::RunThread()
{
if (IsRun())
return TRUE;

this->SetExitState(FALSE);
this->SetPauseState(FALSE);
this->SetSuspendState(FALSE);

this->m_hThread = chBEGINTHREADEX( NULL, 0, CMyThread::ThreadFunc, (void*)this, 0, &this->m_dwThreadId);

if (NULL == this->m_hThread)
{
WQFTRACE("%s线程创建失败errorno=%d /n", this->m_sThreadName, ::GetLastError());
return FALSE;
}

this->SetRunState(TRUE);

return TRUE;
}

DWORD WINAPI CMyThread::ThreadFunc(LPVOID pParam)
{
CMyThread* pThread = (CMyThread*)pParam;

if (!pThread->m_hThread)
{
WQFTRACE("%s线程句柄已失效! /n", pThread->m_sThreadName);
pThread->AfterWork();
pThread->SetRunState(FALSE);
return 0;

}

if (!pThread->BeforeWork())
{
pThread->SetRunState(FALSE);
pThread->AfterWork();
return 0;
}

while (!pThread->IsExit())
{
if (pThread->IsPause())
{
Sleep(1);
}
else
{
if (!pThread->Work())
break;
}
}
pThread->AfterWork();
pThread->SetRunState(FALSE);
return 0;
}

BOOL CMyThread::StopThread( DWORD dwDelayTime )
{
this->SetExitState(FALSE);

DWORD dwTime = ::timeGetTime();
while ((::timeGetTime()-dwTime) < dwDelayTime)
{
if (!this->IsRun())
{
return TRUE;
}
Sleep(10);
}

if (this->m_hThread)
{
static DWORD g_ThreadTerminateCount=0;
if (::TerminateThread(this->m_hThread, ++g_ThreadTerminateCount))
{
WQFTRACE("**********强制退出%s线程! /n", this->m_sThreadName);
WQFASSERT(FALSE);
}
}

this->CloseThread();
return TRUE;
}

BOOL CMyThread::SuspendThread()
{
return TRUE;
}

BOOL CMyThread::ResumeThread()
{
return TRUE;
}

void CMyThread::SetThreadName(CString sThreadName)
{
}

CString CMyThread::GetThreadName()
{
return this->m_sThreadName;
}

HANDLE CMyThread::GetThreadHandle()
{
return this->m_hThread;
}

DWORD CMyThread::GetThreadID()
{
return this->m_dwThreadId;
}

BOOL CMyThread::CloseThread()
{
if (this->m_hThread)
{
::CloseHandle(this->m_hThread);
this->m_hThread = NULL;
this->m_dwThreadId = 0;
}
return TRUE;
}
/************************************************************************

版权所有 (C)2008, 陈彦旭。

文件名称： MyProcess.h
内容摘要： 线程资源管理和使用
其它说明：
当前版本： 1.0.0.0
作 者： 陈彦旭
完成日期： 2008年01月20日

************************************************************************/

#if !defined(AFX_MYPROCESS_H__F958678E_5978_421D_BE7E_56D6266DE6FB__INCLUDED_)
#define AFX_MYPROCESS_H__F958678E_5978_421D_BE7E_56D6266DE6FB__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
typedef BOOL (*ProcessCallback)(LPVOID lpUser, DWORD dwCommand, LPVOID lpData);
#include "MyThread.h"

typedef enum {

PROCESS_COMMAND_BEFORE,
PROCESS_COMMAND_PROCESS,
PROCESS_COMMAND_AFTER,
PROCESS_COMMAND_DELETE,

} process_command_t;

class CMyProcess : public CMyThread
{
public:
CMyProcess();
virtual ~CMyProcess();

private:
LPVOID m_lpUser;
ProcessCallback m_pCallback;

public:
void SetCallback(LPVOID lpUser, ProcessCallback callback);

virtual void DeleteData(void *pData);

BOOL Init();
BOOL ReInit();
BOOL UnInit();

private:
BOOL Work();
BOOL BeforeWork();
BOOL AfterWork();
BOOL Process(void *pData);
};

#endif // !defined(AFX_MYPROCESS_H__F958678E_5978_421D_BE7E_56D6266DE6FB__INCLUDED_)
// MyProcess.cpp: implementation of the CMyProcess class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MyProcess.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMyProcess::CMyProcess()
{
this->m_lpUser = NULL;
this->m_pCallback = NULL;
}

CMyProcess::~CMyProcess()
{
this->UnInit();
}

void CMyProcess::SetCallback(LPVOID lpUser, ProcessCallback callback)
{
this->m_lpUser = lpUser;
this->m_pCallback = callback;
}

void CMyProcess::DeleteData(void *pData)
{
this->m_pCallback(this->m_lpUser, PROCESS_COMMAND_DELETE, pData);
}

BOOL CMyProcess::Work(void)
{
return this->Process(NULL);
}

BOOL CMyProcess::BeforeWork()
{
return this->m_pCallback(this->m_lpUser, PROCESS_COMMAND_BEFORE, NULL);
}

BOOL CMyProcess::AfterWork()
{
return this->m_pCallback(this->m_lpUser, PROCESS_COMMAND_AFTER, NULL);
}

BOOL CMyProcess::Init()
{
return TRUE;
}

BOOL CMyProcess::ReInit()
{
return TRUE;
}

BOOL CMyProcess::UnInit()
{
return TRUE;
}

BOOL CMyProcess::Process(void* pData)
{
return this->m_pCallback(this->m_lpUser, PROCESS_COMMAND_PROCESS, pData);
}
/************************************************************************

版权所有 (C)2008, 陈彦旭。

文件名称： MyMutex.h
内容摘要： 互斥资源管理和使用
其它说明：
当前版本： 1.0.0.0
作 者： 陈彦旭
完成日期： 2008年01月20日

************************************************************************/

#if !defined(AFX_MYMUTEX_H__A0C8824F_B61A_443B_83DA_7F73FC0FD481__INCLUDED_)
#define AFX_MYMUTEX_H__A0C8824F_B61A_443B_83DA_7F73FC0FD481__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CMyMutex
{
public:
CMyMutex();
virtual ~CMyMutex();
public:
BOOL Lock(DWORD dwLockTime=INFINITE);
void Unlock();
BOOL TryLock();

private:
CRITICAL_SECTION m_Mutex;

};

class CUseMutex
{
public:
CUseMutex();
CUseMutex(CMyMutex* plock, BOOL bLock=TRUE, DWORD dwLockTime=INFINITE);
virtual ~CUseMutex();

public:
BOOL IsUseLock();
BOOL UseLock(DWORD dwLockTime=INFINITE);
BOOL UseLock(CMyMutex* plock, BOOL bLock, DWORD dwLockTime=INFINITE);
void UseUnlock();

private:
BOOL m_bLock;
CMyMutex* m_pLock;
};

#endif // !defined(AFX_MYMUTEX_H__A0C8824F_B61A_443B_83DA_7F73FC0FD481__INCLUDED_)

// MyMutex.cpp: implementation of the CMyMutex class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MyMutex.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMyMutex::CMyMutex()
{
::InitializeCriticalSection(&this->m_Mutex);
}

CMyMutex::~CMyMutex()
{
::DeleteCriticalSection(&this->m_Mutex);
}

BOOL CMyMutex::Lock(DWORD dwLockTime)
{
::EnterCriticalSection(&this->m_Mutex);
return TRUE;
}

void CMyMutex::Unlock()
{
::LeaveCriticalSection(&this->m_Mutex);
}

BOOL CMyMutex::TryLock()
{
#if(_WIN32_WINNT >= 0x0400)
::TryEnterCriticalSection(&this->m_Mutex);
#else
::EnterCriticalSection(&this->m_Mutex);
#endif
return FALSE;
}

CUseMutex::CUseMutex()
{
this->m_pLock = NULL;
this->m_bLock = FALSE;
}

CUseMutex::CUseMutex(CMyMutex* plock, BOOL bLock, DWORD dwLockTime)
{
this->m_pLock = plock;
this->m_bLock = FALSE;

if (this->m_pLock && bLock)
{
this->m_bLock = this->m_pLock->Lock(dwLockTime);
}
}

CUseMutex::~CUseMutex()
{
this->UseUnlock();
}

BOOL CUseMutex::IsUseLock()
{
return (this->m_pLock && this->m_bLock);
}

BOOL CUseMutex::UseLock(DWORD dwLockTime)
{
if (this->m_pLock && !this->m_bLock)
this->m_bLock = this->m_pLock->Lock(dwLockTime);

return this->m_bLock;
}

BOOL CUseMutex::UseLock(CMyMutex* plock, BOOL bLock, DWORD dwLockTime)
{
this->UseUnlock();

this->m_pLock = plock;
this->m_bLock = FALSE;

if (this->m_pLock && bLock)
return this->m_bLock = this->m_pLock->Lock(dwLockTime);

return FALSE;
}

void CUseMutex::UseUnlock()
{
if (this->IsUseLock())
this->m_pLock->Unlock();

this->m_bLock = FALSE;
}

Answer 5

线程管理主要涉及同步、互锁问题。使用信号量进行同步，这也是操作系统实现同步的最高效的方法。公共(全局)变量的使用要上锁，不过要注意使用多个锁时造成的死锁问题。