多线程的互斥锁

class Mutex
{
public:
	Mutex() { pthread_mutex_init(&m_mutex, NULL); }
	~Mutex() { pthread_mutex_destroy(&m_mutex); }
private:
	DISALLOW_COPY_AND_ASSIGN(Mutex);
public:
	void lock() { pthread_mutex_lock(&m_mutex); }
	void unlock() { pthread_mutex_unlock(&m_mutex); }
	pthread_mutex_t* getPthreadMutex()
	{
		return &m_mutex;
	}
private:
	pthread_mutex_t m_mutex;
};

class MutexGuard
{
public:
	MutexGuard(Mutex& mutex)
		:m_mutex(mutex)
	{
		m_mutex.lock();
	}
	~MutexGuard()
	{
		m_mutex.unlock();
	}
private:
	DISALLOW_COPY_AND_ASSIGN(MutexGuard);
private:
	Mutex& m_mutex;
};

Mutex swy_lock;
typedef std::map<int32_t,int32_t> SwyMap;
SwyMap test_map;
void initMap()
{
	for (int i = 0; i < 5; i++)
	{
		test_map[i] = i;
	}
}

void addMap()
{
	swy_lock.lock();			//不推荐这样用 因为这样 极有可能中间return退出 没有执行解锁
	for (SwyMap::iterator it = test_map.begin(); it != test_map.end(); ++it)
	{
		int number = it->second;
		it->second = number + 100;
		cout << "add:" << it->second << endl;
	}
	swy_lock.unlock();
}
void printMap()
{
	MutexGuard lock(swy_lock);	//依据对象lock的生命周期 析构自动实现了解锁 推荐
	for (SwyMap::iterator it = test_map.begin(); it != test_map.end(); ++it)
	{
		int number = it->second;
		cout << "print:" << number << endl;
	}
}

class TaskA :public SwyThread
{
public:
	TaskA() {}
	~TaskA() {}
protected:
	virtual void run();
};
void TaskA::run()
{
	addMap();
	join();
}
class TaskB :public SwyThread
{
public:
	TaskB() {}
	~TaskB() {}
protected:
	virtual void run();
};
void TaskB::run()
{
	printMap();
	join();
}


int main()
{
	initMap();
	SwyThread* a = new TaskA();
	SwyThread* b = new TaskB();
	a->start();
	b->start();
}