Boost中的锁

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

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

[cpp] view
plain copy

#include "boost/thread/thread.hpp"  

#include "boost/bind.hpp"  

#include "boost/thread/mutex.hpp"  

  

#include <queue>  

#include <list>  

#include <iostream>  

using namespace std;  

boost::shared_mutex  read_write_mutex;  

boost::mutex lock;  

queue<int> 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;  

}  

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

[cpp] view
plain copy

template<class T>  

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

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

 

◆     读写锁的实现

typedef boost::shared_lock<boost::shared_mutex> readLock;

typedef boost:: unique_lock<boost::shared_mutex> 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<boost::mutex> 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