boost并发编程（三）——共享互斥量

标签：boost   thread   c++   

        前一篇介绍的条件变量可以进行进程间通信，用来实现生产者/消费者模型。今天介绍的共享互斥量用来实现缓冲区读写模型，与生产者/消费者模型不同的地方是，消费者消费产品后，被消费的产品就不存在了，所以消费者线程也要互斥运行；而缓冲区读取线程读取数据后不删除数据，多个线程可以并行读取。这时使用条件变量也不合适了，就要使用共享互斥变量了。

        共享互斥量，顾名思义，既共享，也互斥，读线程之间共享读取数据，使用shared_lock类锁定shared_mutex变量；写线程之间需要独占缓冲区，必须互斥运行，使用unique_lock类锁定shared_mutex变量。这与互斥变量mutex的使用方法不一样，mutex类内部提供了一种lock_guard类即scope_lock类，因此可以用

mutex::scope_lock lock(mu);

这样的形式来锁定互斥量，而share_mutex类没有提供这种内部定义的lock_guard类，所以需要直接使用lock_guard对象，语法如下代码：

shared_mutex rw_mu;

unique_lock<shared_mutex> ul(rw_mu);
shared_lock<shared_mutex> sl(rw_mu);

下面是《指南》上的例子：
 

private:
		int m_x;
		shared_mutex rw_mu;

public:
		rw_data():m_x(0){}

		void write()
		{
			unique_lock<shared_mutex> ul(rw_mu);
			++m_x;
		}

		void read(int& x)
		{
			shared_lock<shared_mutex> sl(rw_mu);
			x = m_x;
		}
};

void writer(rw_data& d)
{
	for(int i = 0; i < 20; ++i)
	{
		this_thread::sleep(posix_time::millisec(10));
		d.write();
	}
}

void reader(rw_data& d, mutex& io_mu)
{
	int x;

	for(int i = 0; i < 10; ++i)
	{
		this_thread::sleep(posix_time::millisec(5));
		d.read(x);
		mutex::scoped_lock lock(io_mu);
		std::cout << "reader:" << x << std::endl;
	}
}

int main()
{
   rw_data d;
   thread_group pool;
   mutex io_mu;
   
   pool.create_thread(bind(reader,ref(d), ref(io_mu)));
   pool.create_thread(bind(reader,ref(d), ref(io_mu)));
   pool.create_thread(bind(reader,ref(d), ref(io_mu)));
   pool.create_thread(bind(reader,ref(d), ref(io_mu)));
   pool.create_thread(bind(writer,ref(d)));
   pool.create_thread(bind(writer,ref(d)));

   pool.join_all();

   return 0;
}

       main函数里的thread_group类和bind适配器后面的文章再说吧，这就是共享互斥量的简单使用方法。

boost并发编程（三）——共享互斥量

标签：boost   thread   c++   

原文地址：http://blog.csdn.net/hh794362661/article/details/46540221