Boost中的锁

原来以为自己很喜欢多线程的程序，可是当真正调试起来却发现很麻烦，你不得不考虑锁的力度，现在我的问题是本该对数据加锁，C++的容器默认是非线程安全的，一个线程读，另一个线程写，迭代器很容易就会指到错误的范围地址，可是程序写到这个程度了也要快毕业答辩了，怎么可能把全部的东西都推到重写啊，想想也只有对代码进行加锁了，虽然效率会低很多吧，Boost 库中有，一般的锁，读写锁，还有一种可重入的递归锁。

我试了下对代码进行加锁，虽然效率不高，但是可以解决目前的问题吧，最好是多数据加锁。

#include "boost/thread/thread.hpp"
#include "boost/bind.hpp"
#include "boost/thread/mutex.hpp"

#include 
#include 
#include 
using namespace std;
boost::shared_mutex  read_write_mutex;
boost::mutex lock;
queue data;
class HelloWorld
{
public:
	bool start;
	void prinf()
	{
		start = 1;
		
		while (start)
		{
			lock.lock();
			while (!data.empty())
			{
				int i = data.front();
				std::cout << "the number is " << " " << i << std::endl;
				data.pop();
			}
			lock.unlock();
		}
	}

	void hello(const std::string& str)
	{
		std::cout << str << std::endl;
		prinf();
	}

	void hello2(const std::string& str)
	{
		std::cout << str << std::endl;
		lock.lock();
		for (int i = 0; i < 100; i++)
			data.push(i);
		lock.unlock();
	}
};

int main()
{
	HelloWorld obj;
	boost::thread thrd(boost::bind(&HelloWorld::hello2, &obj, "Hello World, I'm a thread!"));
	boost::thread thrd2(boost::bind(&HelloWorld::hello, &obj, "Hello World, I'm a thread hello2!"));
	thrd.join();
	thrd2.join();
	return 0;
}

觉得自己定义的数据结构该是这样的。

template
class  Mydata
{
public:
	T getdata(){}
	void setdata();
	void insert(T);
	void del(int index);
	void clear();
	T front();
	void pop();
	void push(T)
	{
		lock.lock();
		data.push(T);
		lock.unlock();
	}

private:
	boost::mutex lock;
	queue data;
};

一下是摘录网上的资源

   boost锁的概述

boost库中提供了mutex类与lock类，通过组合可以轻易的构建读写锁与互斥锁。

 

▲     mutex对象类

mutex类主要有两种：boost::mutex，boost::shared_mutex，其中mutex有lock和unlock方法，shared_mutex除了提供lock和unlock方法外，还有shared_lock和shared_unlock方法。因此，boost::mutex为独占互斥类，boost::shared_mutex为共享互斥类。

 

■     lock模板类

boost::unique_lock，boost::shared_lock，其中unique_lock为独占锁，shared_lock为共享锁。unique_lock中的T可以为mutex类中的任意一种，如果为shared_mutex，那么boost:: unique_lock类的对象构造函数构造时，会自动调用shared_mutex的shared_lock方法，析构函数里，会自动调用shared_mutex的shared_unlock方法。如果是boost:: unique_lock，则分别自动调用lock和unlock方法。

boost::shared_lock中的T只能是shared_mutex类。

 

◆     读写锁的实现

typedef boost::shared_lock readLock;

typedef boost:: unique_lock writeLock;

 

boost::shared_mutex  rwmutex;

 

void readOnly( )

{

        readLock  rdlock( rwmutex );

        /// do something

}

 

void writeOnly( )

{

        writeLock  wtlock( rwmutex );

        /// do something

}

对同一个rwmutex，线程可以同时有多个readLock，这些readLock会阻塞任意一个企图获得writeLock的线程，直到所有的readLock对象都析构。如果writeLock首先获得了rwmutex，那么它会阻塞任意一个企图在rwmutex上获得readLock或者writeLock的线程。

 

★互斥锁的实现

typedef boost:: unique_lock exclusiveLock;

 

▼递归式的互斥量

boost::recursive_mutex提供一个递归式的互斥量。对于一个实例最多允许一个线程拥有其锁定，如果一个线程已经锁定一个boost::recursive_mutex实例，那么这个线程可以多次锁定这个实例。

● boost::mutex::scoped_lock

boost::mutex io_mutex;

void foo( )

{

        {

                boost::mutex::scoped_lock lock( io_mutex );         /// 锁定

        } /// 解锁

}

 

■其它

boost::mutex

boost::timed_mutex

boost::shared_mutex

boost::recursive_mutex

boost::recursive_timed_mutex

 

boost::lock_guard

boost::shared_lock

boost::upgrade_lock

boost::unique_lock

boost::upgrade_to_unique_lock