原创 boost库之thread之二

互斥锁与共享锁

互斥时下面的锁方法适用

void lock( )

bool try_lock( )

bool timed_lock(boost::system_time const& abs_time)

void unlock( )

多读/单写模式适用于下面这些锁

void lock_shared( )

bool try_lock_shared( )

bool timed_lock_shared(boost::system_time const& abs_time)

void unlock_shared( )

timed_lock有两个重载实现：一个用于相对时间，一个用于绝对时间。

以上的都是锁的概念，最好的解释参考《操作系统》的任意一本教科书。需要注意的是，这些不是全局函数而是成员函数，有不同的锁定类型，它们提供这些函数的实现。锁定类型在下一章节。

boost对shared lock作了一些扩展，有一些方法可以升级到独占状态，其他线程拥有对应的共享所有权，升级会失败。

void lock_upgrade( )

bool unlock_upgrade( )

void unlock_upgrade_and_lock( )

void unlock_and_lock_upgrade( )

void unlock_upgrade_and_lock_shared( )

锁定类型

lock_guard 自动锁

template<typename Mutex>

class lock_guard

{

public:

       explicit lock_guard(Mutex& m_); // 这种类型应该是互斥锁

       lock_guard(Mutex& m_, boost::adopt_lock_t);

};

unique_lock 高级自动锁

template<typename Lockable>
class unique_lock
{
public:
    unique_lock();
    explicit unique_lock(Lockable& m_);

    void swap(unique_lock& other);

    void lock();
    bool try_lock();

    template<typename TimeDuration>
    bool timed_lock(TimeDuration const& relative_time);
    bool timed_lock(::boost::system_time const& absolute_time);

    void unlock();

    bool owns_lock() const;
    operator unspecified-bool-type() const;
    bool operator!() const;

    Lockable* mutex() const;
    Lockable* release();
};

这是一种复杂的自动锁，特点是可以延迟lock，自处理unlock，可以拷贝构造，还可以获得互斥对象（mutex()）。只有在复杂应用时才考虑unique_lock，否则lock_guard与作用域配合作为首选方案。

shared_lock   共享锁

upgrade_lock 升级锁

lock(Lockable1, Lockable2, …) 自由函数

lock(begin, end)   自由函数

try_lock(Lockable1, Lockable2, …) 自由函数

try_lock(begin, end)    自由函数

Mutex    互斥类型

class mutex: boost::noncopyable
{
public:
    void lock();
    bool try_lock();
    void unlock();
    
    typedef unique_lock<mutex> scoped_lock;
};

mutex通常不单独使用，而是配合上面的互斥类。至于那个typedef scoped_lock倒是经常地用。先是定义一个各个线程都可见的mutex对象，在各个线程中用scoped_lock, unique_lock, 或lock_guard。mutex::scoped_lock s1; unque_lock<mutex> s2; lock_guard<mutex> s3;

timed_mutex 带超时的互斥类

class timed_mutex: boost::noncopyable
{
public:
    void lock();
    void unlock();
    bool try_lock();
    bool timed_lock(system_time const & abs_time);

    template<typename TimeDuration>
    bool timed_lock(TimeDuration const & relative_time);

    typedef unique_lock<timed_mutex> scoped_timed_lock;
    typedef scoped_timed_lock scoped_lock;
};

跟上面的mutex类似。

recursive_mutex 递归式的互斥量

recursive_timed_mutex      带超时的递归式的互斥量

shared_mutex             共享互斥量

条件变量

条件变量是个好东西，防止死锁的绝密武器。（我自己这样想的）

condition_variable

class condition_variable

{

public:

    void notify_one();
  void notify_all();
   void wait(boost::unique_lock<boost::mutex>& lock);
   bool timed_wait(boost::unique_lock<boost::mutex>& lock,boost::system_time const& abs_time);
  bool timed_wait(boost::unique_lock<boost::mutex>& lock,duration_type const& rel_time);
};

notify_one()与notify_all()好理解，但是所有的wait都需要一个unique_lock，似乎有点出乎意料。

condition_variable的作用如同一个bool变量，至于为什么在wait部分需要一个unique锁，这源于wait本身的实现需要：在进入wait前加锁，在退出wait后解锁。此时有两种可能的情况，一，如果初始化unique_lock的mutex是全局变量，那么一时刻只有一个线程在while循环中等待condition，其它线程没办法通过循环前的lock关；二、如果mutex和unique_lock一样是局部变量那么每个线程都在while中等待。这两种都行得通。