C++多线程分析

我们开始谈论的线程之前先看看这些线载波前—进程。

进程，它是一个正在执行的程序的实例。是一个程序在其自身的地址空间的一次执行活动。进程是资源申请、调度、和独立执行的基本单位。进程有两部分组成：

1、操作系统用来管理进程的内核对象。内核对象是系统用来存放关于进程的统计信息的地方，它是操作系统内部分配的一块内存块，该内存块是一种数据结构，其成员负责维护该对象的各种信息。

2、地址空间，它包括全部可运行模块、dll模块的代码和数据，也包括动态内存分配的空间。

线程---操作系统调度的最小单位。线程包括在进程中，是进程中实际执行的单位。一个进程中能够同一时候执行多个线程。每一个线程能够执行不同的任务。这就是所谓的多线程。

同一进程中的多个线程将共享该进程中的所有系统资源，如虚拟地址空间、文件描写叙述符和信号处理等，可是同一个进程中的多个线程都有各自的调用栈、寄存器环境和线程本地存储。

对于单核（单CPU）系统来说，即便处理器一次仅仅能执行一个线程，可是操作系统通过时间片轮转技术。在不同的线程之间进行切换，让用户产生能够同一时候处理多个任务的错觉，这种程序执行机制称为软件的多线程。

对于多核（多个CPU）系统来说，这种系统能同一时候进行真正的多线程多任务处理。这种执行机制能够称为硬件的多线程技术。

多线程程序作为一种多任务、并发的工作方式。当然有下面的长处：

1)、提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时非常长时，整个系统都会等待这个操作。此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术。将耗时长的操作（time consuming）置于一个新的线程。能够避免这样的尴尬的情况。

2)、使多CPU系统更加有效。

操作系统会保证当线程数不大于CPU数目时，不同的线程执行于不同的CPU上。

3)、改善程序结构。一个既长又复杂的进程能够考虑分为多个线程，成为几个独立或半独立的执行部分。这种程序会利于理解和改动。

例如以下是我写一个跨平台的线程样例：

Mutex.h

#ifndef HEART_MKITHEART_MMUTEX_H
#define HEART_MKITHEART_MMUTEX_H

#ifdef WIN32
#	include <windows.h>
#else
#	include <pthread.h>
#endif

#ifdef WIN32
typedef CRITICAL_SECTION        MKIT_MUTEX_SECTION;
#	define MKIT_MUTEX_INIT         ::InitializeCriticalSection
#	define MKIT_MUTEX_DESTROY      ::DeleteCriticalSection
#	define MKIT_MUTEX_LOCK         ::EnterCriticalSection
#	define MKIT_MUTEX_UNLOCK       ::LeaveCriticalSection
#else
typedef pthread_mutex_t         MKIT_MUTEX_SECTION;
#	define MKIT_MUTEX_INIT         pthread_mutex_init
#	define MKIT_MUTEX_DESTROY      pthread_mutex_destroy
#	define MKIT_MUTEX_LOCK         pthread_mutex_lock
#	define MKIT_MUTEX_UNLOCK       pthread_mutex_unlock
#endif

class Mutex
{
public:
	Mutex()
	{
		MKIT_MUTEX_INIT(&m_mutex
#ifndef _WIN32
			, NULL
#endif
			);
	}

	virtual ~Mutex() {MKIT_MUTEX_DESTROY(&m_mutex);}
	virtual void Lock() const {MKIT_MUTEX_LOCK(&m_mutex);}
	virtual void Unlock() const { MKIT_MUTEX_UNLOCK(&m_mutex); }

private:
	mutable MKIT_MUTEX_SECTION m_mutex;
};

class AutoLock
{
public:
	AutoLock(const Mutex& mutex, bool autolocked = true) : m_mutex(&mutex), m_locked(true)
	{
		if(autolocked)
		{
			m_mutex->Lock();
			m_locked = autolocked;
		}
	};

	~AutoLock()
	{
		if(m_locked)
		{
			m_mutex->Unlock();
		}
	};

private:
	const Mutex* m_mutex;
	bool m_locked;
};

#ifndef LOCK
#	define LOCK(mutex) AutoLock locker(mutex)
#endif

#endif//HEART_MKITHEART_MMUTEX_H

Thread.h

#ifndef HEART_MKITHEART_MTHREAD_H
#define HEART_MKITHEART_MTHREAD_H

#include "Mutex.h"

#define RET_SUCCEED 0

class Runnable
{
public:
	virtual void Run() = 0;
};

class Thread : public virtual Runnable
{
	Thread(const Thread&);
	const Thread& operator=(const Thread&);

public:
	Thread();
	~Thread();

#ifdef WIN32
	static unsigned int WINAPI ThreadFun(void* t);
#else
	static void* ThreadFun(void* t);
#endif

	int Start(void);
	int Stop(void);

	inline bool IsRunning(void) { return m_running; }
	inline void SetRunning(bool x) { m_running = x; }
	inline unsigned short GetWaitTime(void) { return m_waitTime; }
	inline void SetWaitTime(unsigned short uTime) { m_waitTime = uTime;}
	inline void SetRunnable(Runnable* pRunnable){ m_runnable = pRunnable; }

public :
	virtual void Run();

protected:
	void WatiTime(int mTime);

private:
#ifdef WIN32
	HANDLE          m_handle;
	unsigned int    m_threadID;
#else
	pthread_t       m_thread_t;
	pthread_attr_t  m_attr;
#endif

private:
	unsigned short	m_waitTime;
	bool			m_running;
	Runnable*		m_runnable;
	Mutex          m_mutex;
};

#endif//HEART_MKITHEART_MTHREAD_H

Thread.cpp

#ifdef WIN32
#	include <process.h>
#else
#	include <sys/time.h>
#	include <sys/types.h>
#endif

#include "Thread.h"

Thread::Thread() : m_handle(0), m_runnable(0), m_running(false), m_waitTime(40)
{
}

Thread::~Thread()
{
	Stop();
}

void Thread::Run()
{
	if(m_runnable)
	{
		m_mutex.Lock();
		m_runnable->Run();
		m_mutex.Unlock();
	}
	WatiTime(m_waitTime);
}

#ifdef WIN32
unsigned int Thread::ThreadFun( void* t )
#else
void * Thread::ThreadFun( void* t )
#endif
{
	Thread *p = (Thread*)(t);
	if(t)
	{
		while (p->IsRunning())
		{
			p->Run();
		}
#ifdef WIN32
		_endthreadex(0);
#else
		pthread_exit((void*)0);
#endif
	}
	return RET_SUCCEED;
}

int Thread::Start( void )
{
	if(!IsRunning())
	{
#ifdef WIN32
		m_handle = (HANDLE)_beginthreadex(NULL, 0, ThreadFun, this, 0, &m_threadID);//CREATE_SUSPENDED
#else
		pthread_attr_init(&m_attr);
		pthread_attr_setdetachstate(&m_attr, PTHREAD_CREATE_DETACHED);

		if (-1 == pthread_create(&m_thread_t, &m_attr, ThreadFun, this))
		{
			SetRunning(false);
			return -1;
		}
#endif
		SetRunning(true);
	}
	return RET_SUCCEED;
}

int Thread::Stop( void )
{
	if (IsRunning())
	{
		m_mutex.Lock();
		SetRunning(false);
		m_mutex.Unlock();
	}

#ifdef Win32
	if(m_handle)
	{
		::WaitForSingleObject(m_handle, 50);
		::CloseHandle(m_handle);
		m_handle = NULL;
	}
#endif
	return RET_SUCCEED;
}

#ifdef WIN32
void Thread::WatiTime(int mTime)
{
	Sleep(mTime);
}

#else

pthread_cond_t  g_timer_cond;
pthread_mutex_t g_timer_mutex;

void Thread::WatiTime(int mTime)
{
	struct timeval temp_timeout;
	gettimeofday(&temp_timeout, 0);

	struct timespec timeOut;

	timeOut.tv_sec = temp_timeout.tv_sec;
	timeOut.tv_nsec = (temp_timeout.tv_usec  + mTime * 1000) * 1000;

	pthread_cond_timedwait(&g_timer_cond, &g_timer_mutex, &timeOut);
}
#endif

版权声明：本文博客原创文章，博客，未经同意，不得转载。