发信站: 饮水思源 (2004年06月11日06:54:38 星期五)
多线程
闭门造车,大家指正
1.建立多线程
1.1 C runtime library 与 多线程
C runtime library 诞生在上世纪70年代。那会多任务还是个新奇的东西，就是压根没想
到为以后的多线程考虑罗。
没有支持多线程当然叫单线程版罗。
支持多线程是个很泛的概念，支持多线程需要要干些什么事呢？
C runtime library 里有些全局变量，静态变量。race condition，对的，会有同步问题
，但绝对不止是同步这么简单，
仔细推敲一下，这些变量就应该每个线程各持一份然后老死不相往来么。
有哪些变量呢？比方说errno...所以你不能在线程中用fopen/fclose fwrite/fread new/
malloc free/delete..
但你把这些都换成CreateFile/ReadFile/WriteFile HeapAlloc/HeapFree
这些个WIN API函数可是可以的，没什么道理好讲，是操作系统的函数。
所以你用C runtime library的单线版就得，
所以说C runtime library单线程版并非就不能用到多线程上。
不过这堆api里也没有一个可替代Stream I/O的,自己写一个？（笑）。
臭规矩是多！有没有别的办法？我把那些个该死的全局变量，静态变量给每个线程留个副
本不就行拉。
实际上ms就是把这些个C runtime library的全局变量，静态变量放到一个叫_tiddata的结
构里边，当然也不光是这些变量
在线程建立的时候每个线程分到一个实例（CreateThread可干不了这事，后面会说到）
好现在每个线程都有这么一个结构了。
但跑fopen/flose等敏感函数要跟那些全局变量，静态变量打交道时，
C runtime library怎么知道你每个线程的那个放全局变量，静态变量的结构实例在什么地
方，
还有编译器怎么知道要连接多线程版还是单线程版
看看编译是的命令行可以看出单线程版是/ML 多线程版是/MT 或是/MD
(用vc的朋友可在setting->c/c++->code generation->use run-time libary中切换)
用个＃defined #else #endif区别是单线程版还是多线程版，是单线程版把那个进程共享
的全局变量，静态变量
声明出来么，就像： extern int errno;
多线程版的话就用个函数返回个指向本线程(线程内共享)errno的指针出来：
extern int* __cdcel _errno(void);
#define errno (*__errno())
这就是多线程版的C runtime library。
最后一个问题，每个线程发配一个包含结构的内存块，要用的时候随便从内存块中的变量
set/get。怎么个实现的拉...
TLS(线程本地存储器)就是用来实现这么个东东的，
每个线程都有那么一份TLS(这个提法不好)，有1000个槽（win2000），每个槽四个字节，
正好放个指针呃
刚刚说到每个线程不是有个数据结构的实例(_tiddata)么，它的指针就放在TLS中，
不过这些槽可不是随便能放的，得向进程申请，调用 DWORD TlsAlloc(),返回的那个DWOR
D就是可放的槽号拉，
用BOOL TlsSetVale(DWORD,LPVOID) / LPVOID TlsGetValue(DWORD) get/set指针。
加载dll时，如果dll有全局变量，静态变量,
你的dll不大可能只有一个线程加载吧，那些个全局变量，静态变量可是每个线程要一份的
每个线程需要一个指向这块内存区的指针,他们占用的槽号是一样的.
让进程调用DWORD TlsAlloc()/TlsFree() 来分配，管理这些槽。（在dll attach/detach
的时候）
每个线程可以用多个槽，不过占用的槽越少越好，毕竟整个进程就能分配出来1000个，nt
下只有64个。very的宝贵啊
好在这些个问题ms都用封装的api搞得服服帖帖，是不是很faint,好像全是废话
1.2 开线程了
开线程可用CreateThread/_beginthread/_beginthreadex/AfxBeginThread
/*CreateThread*/
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD
SIZE_T dwStackSize, // initial stack size
LPTHREAD_START_ROUTINE lpStartAddress, // thread function
LPVOID lpParameter, // thread argument
DWORD dwCreationFlags, // creation option
LPDWORD lpThreadId // thread identifier
);
无视C runtime library的存在，就是没有这么个包含全局变量，静态变量的结构实例分配
出来。
当然你可用压根不用C runtime library中那些“敏感的”函数，或自己处理TLS。呵呵
/*_beginthread && _beginthreadex*/
unsigned long _beginthread( void( __cdecl *start_address )( void * ), unsigned
stack_size, void *arglist )
unsigned long _beginthreadex( void *security, unsigned stack_size,
unsigned ( __stdcall *start_address )( void * ), void *arglist,
unsigned initflag, unsigned *thrdaddr );
有关心C runtime library，其实它也是调用的CreateThread，
辅助api函数threadstartex(LPVOID)的指针作为lpStartAddress送到CreateThread，
start_address，arglist也放到_tiddata里作为lpParameter送到CreateThread
threadstartex(LPVOID)作为thread function跑起来
看到没有，这个函数的LPVOID吃进分配出来的包含arglist和start_address的_tiddata，
_tiddata的指针放进TLS中，
把start_address作为一个普通函数调用（这个提法不好）,arglist作为参数.
总算把C runtime library搞定拉。
但是_beginthread还是不能用，它有个race condition的隐患，
个人揣度ms是想封装CloseHanle(不要windows.h了？方便移植？),反正这个函数公认的蠢
拉，
_beginthreadex没有这个问题，不过自己CloseHanle。能在启动时停下来检查handle,再接
着跑。
1.2 关线程了
既然CreateThread/_beginthread不在考虑之列了，配套的ExitThread/_endthread，也用
不着
_endthreadex与ExitThread/_endthread一样是自杀式函数，线程直接返回，刚返回时_ti
ddata没放掉。
跟CreateThread/_beginthread/_beginthreadex的过程相反
_endthreadex与_endthread都是释放掉_tiddata的内存再调用ExitThread
说到这插一句，你要是在主线程调用ExitThread，其他线程的资源是放不出来的.可能操作
系统会有办法,不过还是不用的好
比方你一个tcp server crash掉的时候,本地端口会进入TIME_WAIT状态,如果server程序重
开时不设定端口SO_REUSEADDR属性
就开不动服务器了.
还有种情况,从message窗口看明明主线程退出了,某个线程要是在WaitForSingleObject()
是退不出来得.
_endthreadex还是用得很少的，除非程序立马会crash。
我们经常需要（绝大多数情况）在另一个线程放个信号出来告诉计算机，你该关某某线程
拉
1.有很多人喜欢用变量，而且不怎么喜欢加volatile，呵呵
而且这个东西有很多弊端，但也有用得着的地方。但前提是不能把这东西做成轮询，
该阻塞的地方就得阻塞住(这个提法不好)。
什么地方用后面会提到。
2.setevent+WaitFor....
注意这里的event可要个会手动重置的，要不消息可能丢失
//module.h
#ifndef _MODULE_
#define _MODULE_
#define RET_ABNORMAL 1L
#define RET_SUCCESS 0L
#define ERR_CREATE_EXITEVENT -1
#define ERR_CREATE_THREAD -2
class PlayerModule
{
public:
PlayerModule();
virtual ~PlayerModule();
//开启线程，注意返回值
int StartThread();
//关闭线程
void StopThread();
//测试是不是有线程attach
bool IsStart() {return NULL == hModuleThread;}
protected:
// 主线程函数
virtual void Run();
HANDLE hExitEvent; //用来给退出信号的句柄
private:
//注意这里的static UINT WINAPI
static UINT WINAPI ThreadProc(LPVOID pParam);
HANDLE hModuleThread;//线程句柄
} ;
#endif
//module.cpp
#include "module.h"
Module::Module()
{
hExitEvent = NULL;
hModuleThread = NULL;
}
PlayerModule::~PlayerModule()
{
StopThread();//清理
}
int Module::StartThread()
{
if(NULL == ( hExitEvent = CreateEvent(NULL,TRUE,FALSE,NULL))) //手动复位
{
return ERR_CREATE_EXITEVENT;
}
HANDLE hThread;
UINT uiThreadId = 0;
hThread = (HANDLE) _beginthreadex(NULL, // attrib
0, // stack
ThreadProc, // thread proc
this, // thread proc param
CREATE_SUSPENDED, // creation mode挂起
&uiThreadId); // thread ID记录下来可做调试依据
// verify the thread handle
if ( NULL != hThread)
{
//continue thread
ResumeThread( hThread );
hModuleThread = hThread;
return RET_SUCCESS;
}
else
{
CloseHandle(hExitEvent);
hExitEvent = NULL;
return ERR_CREATE_THREAD;
}
}
UINT Module::ThreadProc(LPVOID pParam)
{
Module* pThis = reinterpret_cast<Module*>( pParam );
_ASSERTE( pThis != NULL );
pThis->Run();//真正的主线程函数
return RET_SUCCESS;
}
void Module::StopThread()
{
if(hModuleThread)
{
SetEvent(hExitEvent);//放信号
if (WaitForSingleObject(hModuleThread, 5000L) == WAIT_TIMEOUT)//等线程退出
TerminateThread(hModuleThread, RET_ABNORMAL);
CloseHandle(hModuleThread);
CloseHandle(hExitEvent);
hExitEvent = NULL;
hModuleThread = NULL;
}
}
UINT Module::Run()
{
return 0;
}
看到了吧，就三板斧
SetEvent(hExitEvent);//放信号
if (WaitForSingleObject(hModuleThread, 5000L) == WAIT_TIMEOUT)//等线程退出
TerminateThread(hModuleThread, RET_ABNORMAL);//实在不行，恼羞成怒硬退
这样肯定是安全的，如果线程返回RET_ABNORMAL，那肯定是你的run中的循环
没能退出来，
这里的run在超类中重写的。
如果你的run函数本来就是要轮循的，用全局变量也可,不过这么写也不错:
while(true)
{
.......//do something
if(WaitForSingleObject(hExitEvent,0) != WAIT_TIMEOUT)
break;
}
如果有阻塞用轮循代码效率可低多了
比方producer/comsumer模式下，comsumer这头
UINT DeriveFromModule::Run()
{
HANDLE handls[2];
handls[1] = hSem; //这个次序还是蛮重要的
handls[0] = hExitEvent;
while (true)
{
DWORD ret;
ret = WaitForMultipleObjects(2,handls,FALSE,INFINITE);
if (ret == WAIT_OBJECT_0) {
break;
}
....//use Semaphore do something
}
return 0;
}
但如果阻塞的是一个io，比方是个sock。情况又不那么一样拉
实际的办法把io关了，句柄置位，线程判断句柄后退出。
不重用Module，写个IOModule，框架一样的只是没有hExitEvent。
#define INVALID_HANDLE_VALUE NULL
bool RTPSocketComm::IsOpen() const
{
return ( INVALID_HANDLE_VALUE != hComm );
}
void IOModule::StopComm()
{
// Close Socket
if (IsOpen())
{
//调用sock关闭
shutdown(sock, SD_BOTH);
closesocket( sock );
hComm = INVALID_HANDLE_VALUE;
Sleep(50);//50ms
}
// Kill Thread
if (NULL != hIOModuleThread)
{
if (WaitForSingleObject(hIOModuleThread, 5000L) == WAIT_TIMEOUT)//等5s够长了
TerminateThread(hIOModuleThread, 1L);
CloseHandle(hIOModuleThread);
hIOModuleThread = NULL;
}
}
UINT IOModule::Run()
{
DWORD dwBytes = 0L;
....
while( IsOpen() )
{
// 采用阻塞式socket，等待事件通知
dwBytes = recvfrom(....);
or dwBytes = recv(....);
or select(...)+recvfrom(..)|recv(..)
if (dwBytes > 0)
{
...//process buffer
}
else{// 错误
break;
}
}
return 0;
}
在线程外边执行StopComm()关线程。
当然也可重用Module改写run,下面select停靠了三个sock,
对于使用中的sock一般不会在select停1s以上，所以也没什么大开销，回头把sock再关了
就行了
UINT DeriveFromModule::Run()
{
fd_set fdset;
struct timeval tv;
UINT ASock;//接收端口1-3
UINT BSock;
UINT CSock;
GetASocket(&ASock);
GetBSocket(&BSock);
GetCSocket(&CSock);
while (true)
{
tv.tv_sec = 1;//1s
tv.tv_usec = 0;
FD_ZERO(&fdset);
FD_SET(ASock,&fdset);
FD_SET(BSock,&fdset);
FD_SET(CSock,&fdset);
int ret = select(FD_SETSIZE,&fdset,NULL,NULL,&tv);
if ( ret > 0) {
if(FD_ISSET(ASock,&fdset))
{
...
}
else if(FD_ISSET(BSock,&fdset))
{
...
}
else if(FD_ISSET(CSock,&fdset))
{
}
if(WaitForSingleObject(hExitEvent,0) != WAIT_TIMEOUT)
break;
Sleep(0);
}
return 0;
}
select是种比较土的同步io办法拉，不过overlapped io,i/o completion ports又比较多
东西了，而且跟这篇帖子也不怎么靠边
ms恐吓我说用mfc来开发程序时得用AfxBeginThread，不好用_beginthreadex，偶知道mfc
也用Tls的，有AFX_MODULE_PROCESS_STATE,
_AFX_THREAD_STATE ,AFX_MODULE_PROCESS_STATE三个状态要线程局部化。
不过偶在工作线程里不用mfc，这些线程不加载mfc的dll，要不是图mfc做界面快....
所以偶一直非常固执的用_beginthreadex＋winsock api，倒也没出过什么事。到现在为止
偶觉得用_beginthreadex也没什么大问题。
AfxBeginThread的用法类似。
1.3 媒体定时器
比windows api提供的定时器强大多了.定义查看:<mmsystem.h> winmm.lib
实际上每个定时器都是一个后台线程,可用来做采样和视频.做过的人都知道
下面是个包装类,非常之简单,resolution是要求的精度,internalTimerProc是个回调.
//mmTimers.h
#ifndef ___multimedia_timers___
#define ___multimedia_timers___
#include <mmsystem.h>
class CMMTimers
{
public:
CMMTimers(UINT resolution);
virtual ~CMMTimers();
UINT getTimerRes() { return timerRes; };
bool startTimer(UINT period,bool oneShot);//是周期的,还是只激发一次
bool stopTimer();
virtual void timerProc() {};//写处理函数
protected:
UINT timerRes;
UINT timerId;
};
#endif
//mmTimers.cpp
#include "StdAfx.h"
#include "mmTimers.h"
CMMTimers::CMMTimers(UINT resolution) : timerRes(0), timerId(0)
{
TIMECAPS tc;
if (TIMERR_NOERROR == timeGetDevCaps(&tc,sizeof(TIMECAPS)))
{
timerRes = min(max(tc.wPeriodMin,resolution),tc.wPeriodMax);
timeBeginPeriod(timerRes);
}
}
CMMTimers::~CMMTimers()
{
stopTimer();
if (0 != timerRes)
{
timeEndPeriod(timerRes);
timerRes = 0;
}
}
extern "C"
void
CALLBACK
internalTimerProc(UINT id,UINT msg,DWORD dwUser,DWORD dw1,DWORD dw2)
{
CMMTimers * timer = (CMMTimers *)dwUser;
timer->timerProc();
}
bool CMMTimers::startTimer(UINT period,bool oneShot)
{
bool res = false;
MMRESULT result;
result = timeSetEvent(period,timerRes,internalTimerProc,(DWORD)this,oneShot ?
TIME_ONESHOT : TIME_PERIODIC);
if (NULL != result)
{
timerId = (UINT)result;
res = true;
}
return res;
}
bool CMMTimers::stopTimer()
{
MMRESULT result;
result = timeKillEvent(timerId);
if (TIMERR_NOERROR == result)
timerId = 0;
return TIMERR_NOERROR == result;
}
2 互斥
2.1 互斥变量
CRITICAL_SECTION && Mutex
没什么好说的就是不跨进程的时候用CRITICAL_SECTION，CRITICAL_SECTION的速度比Mute
x快太多了
比方说锁个链表：
MYList::MYList()
{
...
InitializeCriticalSection(&criticalsection);
}
MYList::~MYList()
{
DeleteCriticalSection(&criticalsection);
}
inline void MYList::LockList()
{
EnterCriticalSection(&criticalsection);
}
inline void MYList::UnlockList()
{
LeaveCriticalSection(&criticalsection);
}
int MYList::Add(ListMember *mem)
{
EnterCriticalSection(&criticalsection);
....//调链表指针
LeaveCriticalSection(&criticalsection);
......
}
ListMember* MYList::Extract()
{
EnterCriticalSection(&criticalsection);
....//调链表指针
LeaveCriticalSection(&criticalsection);
.....
}
semaphore用来实现producer/consumer模型
比方说上面的链表就可用作一个管道，同步在内部都做好了，比方链表每add一个元素
用ReleaseSemaphore(hSem,1,NULL)发一个通知。consumer这边WaitForSingleObject()返
回，
并用Extract()接收一个
3. 同步
WaitForSingleObject/WaitForMultipleObjects前边都有。
