poco Mutex(互斥量)

作用:
互斥量用于线程间同步。实际上就是锁住某部分指令。
linux 底层的 api 互斥量使用还是很麻烦的。pthread_mutex_init()
pthread_mutex_lock() pthread_mutex_destory()
下面是 Poco 里关于锁的一些实现。

要看 Poco::Mutex 所以我们应该去看基类 Poco::MutexImpl 类的实现。

class Foundation_API MutexImpl{protected:    MutexImpl();    MutexImpl(bool fast);    ~MutexImpl();    void lockImpl();    bool tryLockImpl();    bool tryLockImpl(long milliseconds);    void unlockImpl();private:    pthread_mutex_t _mutex;};

MutexImpl () 默认构造函数主要是执行锁的初始化，初始化为可以递归的锁。即同一个线程可以多次进行锁。

    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);    pthread_mutex_init(&_mutex, &attr)；    pthread_mutexattr_destroy(&attr);

MutexImpl( bool fast ) 带参数构造函数 主要在设置递归锁的时候判断标志位 fast.如果 fast 为true 那么为不可递归的互斥量。也就是下面将要讲到的 Poco::FastMutex ,如果为 false 那么就是可以递归的互斥量也就是 Poco::Mutex。

    pthread_mutexattr_settype(&attr, fast ? PTHREAD_MUTEX_NORMAL : PTHREAD_MUTEX_RECURSIVE);

主要的方法:

    void lockImpl();//加锁    bool tryLockImpl();//调用tryLock 函数。成功返回 true,失败返回 false.    bool tryLockImpl(long milliseconds);//调用pthread_mutex_timeLock() 函数。成功返回 true,失败返回 false.    void unlockImpl();//解锁。

Poco::Mutex 私有继承 MutexImpl

class Foundation_API Mutex: private MutexImpl

Poco::Mutex 创建的是默认的可以递归的互斥量(需要注意的是同一线成可以多次锁，但是要多次解锁，不同线程不行)。

    void lock();    void lock(long milliseconds);    bool tryLock();    bool tryLock(long milliseconds);//等待获取锁，到达时间没有获取返回 false。    void unlock();

Poco 最简单的互斥量使用,两个线程，每个线程都先获取锁 2S 之后释放锁。

#include <iostream>#include <Poco/Mutex.h>#include <Poco/Thread.h>#include <unistd.h>class Worker : public Poco::Runnable{public:    Worker( Poco::Mutex& mtx ):        _mtx(mtx)    {    }    void run( )    {        //获取锁        _mtx.lock();        std::cout << Poco::Thread::currentTid() << "   get mtx" << std::endl;        sleep( 2 );        _mtx.unlock();    }private:    Poco::Mutex& _mtx;};int main( ){    Poco::Mutex mtx;    Poco::Thread th1,th2;    Worker w1( mtx );    Worker w2( mtx );    th1.start( w1 );    th2.start( w2 );    th1.join();    th2.join();}

可以一个线程先获取了锁，等了两秒之后先获取锁的线程释放了锁，第二个线程才能获取锁。

Poco::FastMutex 继承于 FastMutexImpl
FastMutexImpl 继承于 Poco::MutexImpl

FastMutexImpl 的构造函数指定调用 MutexImpl( true ) 够造一个不能多次锁的普通锁对象。

所以 FastMutex 的功能和 Mutex 的功能一样只是，不能多次锁，否则造成死锁。

在 Poco 互斥量里有一个不得不说的类它就是 Poco::ScopedLock。是一个模板类。它只有3 个 public 方法。
两个构造函数，第一个ScopedLock(M& mutex)是调用传进来的 互斥量的 lock() 方法。第二个ScopedLock(M& mutex, long milliseconds) 是调用传捡来的互斥量的 lock( milliseconds ) 方法。

一个析构函数调用 互斥量的 unlock() 方法。所以使用 Poco::ScopeLock 类的作用是在构造的时候会自动获取锁，在函数退出的时候自动释放锁。
ScopeLock 在Mutex 和 FastMutex 都有实例化。所以使用的锁如果是
Mutex 类型的那么只要
Poco::Mutex::ScopedLock s( _mtx );
Poco::FastMutex::ScopeLock( _mtx );

template <class M>class ScopedLock{public:    explicit ScopedLock(M& mutex): _mutex(mutex)    {        _mutex.lock();    }    ScopedLock(M& mutex, long milliseconds): _mutex(mutex)    {        _mutex.lock(milliseconds);    }    ~ScopedLock()    {        try        {            _mutex.unlock();        }        catch (...)        {            poco_unexpected();        }    }

下面还是刚刚那个例子。现在改成使用 ScopeLock 来实现。

#include <iostream>#include <Poco/Mutex.h>#include <Poco/Thread.h>#include <unistd.h>class Worker : public Poco::Runnable{public:    Worker( Poco::Mutex& mtx ):        _mtx(mtx)    {    }    void run( )    {        //获取锁        Poco::Mutex::ScopedLock s( _mtx );      std::cout << Poco::Thread::currentTid() << "   get mtx" << std::endl;        sleep( 2 );    }private:    Poco::Mutex& _mtx;};int main( ){    Poco::Mutex mtx;    Poco::Thread th1,th2;    Worker w1( mtx );    Worker w2( mtx );    th1.start( w1 );    th2.start( w2 );    th1.join();    th2.join();}

从上面代码可以看出来。使用 ScopeLock 可以不需要关心释放锁。所以推荐使用 ScopeLock.

既然有 ScopeLock() 类可以自动帮我我获取锁，退出函数帮我们释放锁。那么有没有哪个类，可以帮我们在自动释放锁，退出函数的时候自动加锁。ScopedUnlock 类就可以实现这样的功能。

应用场景:
比如说当一个线程(A)获取了锁需要从数据库链接池获取一个数据链接，但是此时没有，那么并且需要等到另外的线程(B,C,D)的释放链接信号才能继续执行。但线程B 把链接放回池需要获取锁，这个时候那应该就是 线程 A 在进入阻塞等待之前先释放锁，然后 B 获取了锁，把链接放回去，才发送信号。A 接收到信号之后，激活继续向下 运行，在退出函数的时候重新获取锁。
例子先不写了。下一篇的 Poco::Event 线程间通信可在细述。

转载请注明出处
http://blog.csdn.net/yuhaiyang457288/