多线程笔记2

发信站: 饮水思源 (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前边都有。