多线程及互斥锁整理

多线程及互斥锁整理

多线程的创建

这个函数是一个应用程序定义的函数的占位符，作为一个 线程的起始地址。在调用CreateThread函数时，指定该地址。LPTHREAD_START_ROUTINE类型定义了该回调函数的 指针。 ThreadProc是一个应用程序定义的函数的名称的占位符。

DWORD WINAPI ThreadProc(LPVOID lpParameter); [1]

参数

lpParameter

接收线程传递给函数使用的CreateThread函数lpParameter参数数据。

返回值

函数应该返回一个值，指出其成功或失败。

备注

一个进程可以通过调用GetExitCodeThread函数获取由CreateThread创建的线程的ThreadProc函数的返回值。

来自：百科解释

本文：http://write.blog.csdn.net/postedit

#ifdef WIN32
static DWORD WINAPI ThreadProc( void* lpParameter)
{
	Thread *thread = (Thread *)lpParameter;
	thread->action();
	return 0;
}
#else
static void* ThreadProc( void* lpParameter)
{
	Thread *thread = (Thread *)lpParameter;
	return thread->action();
}
#endif

多线程的创建及销毁

Thread::Thread( int detached = 0 )
{
	status = new_created;
#ifdef WIN32
#else
	pthread_attr_init( &th_attr );
	if ( detached )
	{
		pthread_attr_setdetachstate( &th_attr, PTHREAD_CREATE_DETACHED );
	}
#endif
}

Thread::~Thread(){
#ifdef WIN32
	if ( status == running ) {
		TerminateThread(thread_id, 0);
	}
#else
//	if ( status == running ) {
//		pthread_cancel(thread_id);
//	}
#endif
}

执行

int Thread::start()
{
#ifdef WIN32
	if (status == new_created ) {
		thread_id = CreateThread(NULL, 0, ThreadProc, this, 0, NULL);
		if ( thread_id ){
			status = running;
			return 0;
		}
	}
#else
	if ( status == new_created 
		&& !pthread_create(&thread_id, &th_attr, ThreadProc, this) ) {
		status = running;
		return 0;
	}
#endif
	return -1;
}

停止

int Thread::stop(int nKill)
{
#ifdef WIN32
if ( status == running ) {
if(nKill)
{
TerminateThread(thread_id, 0);
}
status = stopped;
return 0;
}
#else
if ( status == running ) {
if(nKill)
{
pthread_cancel(thread_id);
usleep(100); // let thread process left work
}
status = stopped;
return 0;
}
#endif
return -1;
}

 

互斥锁类型：

* PTHREAD_MUTEX_TIMED_NP，这是 缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个 等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。

* PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。

* PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。

* PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

下面是linux下和Windows下的创建方式

Mutex::Mutex(int mutex_type)
{
#ifdef 
	mutex = CreateMutex(NULL,false,NULL);
#else
	pthread_mutexattr_t attr;
	pthread_mutexattr_init(&attr);
	if (pthread_mutexattr_settype(&attr,mutex_type))
	{
		//PTHREAD_MUTEX_RECURSIVE_NP 嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争
		pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE_NP); //Invalid mutex_type,use defualt type
	}
	pthread_mutex_init(&mutex,&attr)
#endif
}

销毁

Mutex::~Mutex()
{
#ifdef WIN32
	CloseHandle(mutex);
#else
	pthread_mutex_destroy(&mutex);int Mutex::lock()
{
#ifdef WIN32
	if (WAIT_FAILED == WaitForSingleObject(mutex,INFINITE))
	{
		return -1;
	}
	else
	{
		return 0;
	}
#else
	return pthread_mutex_lock(&mutex);
#endif
}#endif
}
锁定

int Mutex::lock()
{
#ifdef WIN32
	if (WAIT_FAILED == WaitForSingleObject(mutex,INFINITE))
	{
		return -1;
	}
	else
	{
		return 0;
	}
#else
	return pthread_mutex_lock(&mutex);
#endif
}



解锁

int Mutex::unlock() {
#ifdef WIN32
	if ( ReleaseMutex(mutex) )
		return 0;
	else 
		return -1;
#else
	return  pthread_mutex_unlock(&mutex);
#endif
}

本文：http://write.blog.csdn.net/postedit

未完待续。。。