BOOST线程、锁与Bind函数的使用

BoostLock.h

#ifndef BoostLock_h__
#define BoostLock_h__

#include "stdafx.h"

//①互斥类;
extern boost::mutex _IOMutex;

//②读写锁;
typedef boost::shared_lock< boost::shared_mutex > ReadLock;//共用资源(多人读);
typedef boost::unique_lock< boost::shared_mutex > WriteLock;//独占资源(一人写);

//②读写锁类的全局变量;
extern boost::shared_mutex _RWMute;

#endif // BoostLock_h__

BoostLock.cpp

#include "BoostLock.h"

boost::mutex _IOMutex;
boost::shared_mutex _RWMute;

自定义锁结构 : LHCRWMutex.h

#ifndef LHCRWMutex_h__
#define LHCRWMutex_h__

////////////////////////////
//自定义读写锁;
//使用方法;
//LHCRWMutex rwMutex;
//LHCRWMutex::ReadLock rdl(rwMutex);
//
//LHCRWMutex::WriteLock rdl(rwMutex);
///////////////////////////
struct LHCRWMutexPrivate;

template<class T>
class LHCReadMutexLock
{
public:
    LHCReadMutexLock( T & lock )
        :_lock(lock)
    {
        _lock.BeginRead();
    }
    ~LHCReadMutexLock()
    {
        _lock.EndRead();
    }
private:
    T & _lock;
};

template<class T>
class LHCWriteMutexLock
{
public:
    LHCWriteMutexLock( T & lock )
        :_lock(lock)
    {
        _lock.BeginWrite();
    }
    ~LHCWriteMutexLock()
    {
        _lock.EndWrite();
    }
private:
    T & _lock;
};

class LHCRWMutex
{
public:
    LHCRWMutex();
    ~LHCRWMutex();
    LHCRWMutex( const LHCRWMutex & r );
    LHCRWMutex & operator=( const LHCRWMutex & r );

    //注意使用方法;
    typedef LHCReadMutexLock<LHCRWMutex> ReadLock;
    typedef LHCWriteMutexLock<LHCRWMutex> WriteLock;

public:
    void BeginWrite();
    void EndWrite();

    void BeginRead();
    void EndRead();

private:
    LHCRWMutexPrivate * _p;
};

#endif // LHCRWMutex_h__

LHCRWMutex.cpp

#include "LHCRWMutex.h"

#include <boost/thread/shared_mutex.hpp>

struct LHCRWMutexPrivate
{
    LHCRWMutexPrivate()
    {

    }
    bool TryWrite()
    {
        return _Atomic.try_lock();
    }
    bool TryRead()
    {
        return _Atomic.try_lock_shared();
    }

    bool TryUpgrade()
    {
        return _Atomic.try_lock_upgrade();
    }

    void BeginWrite()
    {
        _Atomic.lock();
    }
    void EndWrite()
    {
        _Atomic.unlock();
    }

    void BeginRead()
    {
        _Atomic.lock_shared();
    }
    void EndRead()
    {
        _Atomic.unlock_shared();
    }

    void EndWriteAndBeginRead()
    {
        _Atomic.unlock_and_lock_shared();
    }

    void BeginUpgrade()
    {
        _Atomic.lock_upgrade();
    }
    void EndUpgrade()
    {
        _Atomic.unlock_upgrade();
    }

    void EndUpgradeAndBeginWrite()
    {
        _Atomic.unlock_upgrade_and_lock();
    }
    void EndUpgradeAndBeginRead()
    {
        _Atomic.unlock_upgrade_and_lock_shared();
    }

    void EndUpgradeAndBeginUpgrade()
    {
        _Atomic.unlock_and_lock_upgrade();
    }

    boost::shared_mutex _Atomic;
};

LHCRWMutex::LHCRWMutex()
    :_p(new LHCRWMutexPrivate)
{
}

LHCRWMutex::LHCRWMutex( const LHCRWMutex & r )
{
    _p = new LHCRWMutexPrivate;
}


LHCRWMutex::~LHCRWMutex()
{
    delete _p;
}

LHCRWMutex & LHCRWMutex::operator=( const LHCRWMutex & r )
{
    if ( this != &r )
    {
        delete _p;
        _p = new LHCRWMutexPrivate();
    }
    return *this;
}

void LHCRWMutex::BeginWrite()
{
    _p->BeginWrite();
}

void LHCRWMutex::EndWrite()
{
    _p->EndWrite();
}

void LHCRWMutex::BeginRead()
{
    _p->BeginRead();
}

void LHCRWMutex::EndRead()
{
    _p->EndRead();
}

线程A : ThreadA.h

#ifndef ThreadA_h__
#define ThreadA_h__

#include "stdafx.h"

class ThreadA
{
public:
    ThreadA(void);
    ~ThreadA(void);

    void Start();
    static void Counting( int numb );
};

#endif // ThreadA_h__

ThreadA.cpp

#include "ThreadA.h"
#include "BoostLock.h"

ThreadA::ThreadA(void)
{
}


ThreadA::~ThreadA(void)
{
}

void ThreadA::Start()
{
    //读锁使用实例;
    ReadLock rdLock(_RWMute);

    //Counting为static函数;
    boost::thread thrdA( boost::bind( &Counting, 50 ));
}

void ThreadA::Counting( int numb )
{
    //写锁使用实例;
    WriteLock rdLock(_RWMute);

    //互斥锁;
    //boost::mutex::scoped_lock lock(_IOMutex);
    for( int i = 0; i < numb; ++i )
    {
        std::cout << numb << std::endl;
        std::cout.flush();
    }
}

线程B : ThreadB.h

#ifndef ThreadB_h__
#define ThreadB_h__

#include "stdafx.h"

class ThreadB
{
public:
    ThreadB(void);
    ~ThreadB(void);

    void Start();
    void Counting( int numb );
};

#endif // ThreadB_h__

ThreadB.cpp

#include "ThreadB.h"
#include "BoostLock.h"

ThreadB::ThreadB(void)
{
}


ThreadB::~ThreadB(void)
{
}

void ThreadB::Start()
{
    //读锁使用实例;
    ReadLock rdLock(_RWMute);

    //Counting为非static函数;
    boost::thread thrdA( boost::bind( &ThreadB::Counting, this, 55 ));
}

void ThreadB::Counting( int numb )
{
    //写锁使用实例;
    WriteLock rdLock(_RWMute);

    //互斥锁;
    //boost::mutex::scoped_lock lock(_IOMutex);
    for( int i = 0; i < numb; ++i )
    {
        std::cout << numb << std::endl;
        std::cout.flush();
    }
}

main.cpp

#include "stdafx.h"

#include <iostream>

#include <winsock.h>

#include "ThreadA.h"
#include "ThreadB.h"
#include "LHCRWMutex.h"
#include "BoostLock.h"

using namespace std;

//③自定义互斥类;
LHCRWMutex rwMutex;
void Counting( int numb )
{
    //③自定义互斥锁;
    LHCRWMutex::WriteLock wdl(rwMutex);
    //LHCRWMutex::ReadLock rdl(rwMutex);//共享锁;

    //①互斥锁，独占资源;
    //boost::mutex::scoped_lock lock(_IOMutex);

    for( int i = 0; i < numb; ++i )
    {
        std::cout << numb << std::endl;
    }
}

int main( int argc, char * argv[] )
{
    //计数;
    DWORD m_tick1 = GetTickCount();

    cout << "hello"<<endl;

    //-----------------------------------------------------------
    //boost::thread的构造函数，以一个不需任何参数的函数对象作为参数，并且没有返回值;
    //参数可以是函数对象或者函数指针。并且这个函数无参数，并返回void类型;
    //当以一个需要参数的函数作为thread构造函数时，使用boost::bind;
    //------------------------------------------------------------

    //-----------------------------------------------------------
    //boost::bind
    //1.静态函数fun;
    //若fun 有n个参数. 则 bind 需要 n+1 个参数: 原始函数的地址 以及 n个要绑定的参数.;
    //例boost::bind(&fun, 3, 4);         boost::bind(&fun, 3, _1)(4);//4将代替_1占位符;
    //boost::bind(&fun, _1, _2)(3, 4);   boost::bind(&fun, _1, _1)(3);//3将代替_1占位符;
    //boost::bind(&fun, _2, _1)(3, 4); // 3将代替_1占位符, 4将代替_2占位符;
    //
    //2.非静态函数
    //若A::func有n个参数, 则 bind 要有 n+2 个参数: 指向成员函数fun的指针, 绑定到this的对象, n个参数
    //例;
    //struct A {void func(int x, int y) {cout << x << "," << y << endl;}};
    //A a;
    //A* pa = new A; //指针;
    //boost::shared_ptr<A> ptr_a(pa);//智能指针;
    //现在要向像 A::func 这样的非静态成员函数绑定;
    //
    //boost::bind(&A::func, a, 3, 4)();    //输出 3, 4;
    //boost::bind(&A::func, pa, 3, 4)();   //输出 3, 4;
    //boost::bind(&A::func, ptr_a, 3, 4)();//输出 3, 4;
    //同样可以用 _1 这样的占位符. 如:;
    //boost::bind(&A::func, _1, 3, 4)(ptr_a);//输出 3, 4;

    //可以看出. 不论传递给bind 的第2个参数是 对象. 对象指针. 还是智能指针. bind函数都能够正常工作.;
    //------------------------------------------------------------
    boost::thread trdA( boost::bind( &Counting, 10 ) );
    boost::thread trdB( boost::bind( &Counting, 11 ) );

    //计数;
    DWORD m_tick2 = GetTickCount();

    //等待线程结束;
    trdA.join();
    trdB.join();

    //放弃余下的时间片;
    trdA.yield();

    //计数;
    DWORD m_tick3 = GetTickCount();
    int tickA = m_tick2 - m_tick1;
    int tickB = m_tick3 - m_tick2;

    cout << "-------------------"<<endl;

    //ThreadA::Counting为static函数，可直接调用;
    ThreadA classThreadA;
    boost::thread trdC( boost::bind( &ThreadA::Counting, 51 ) );
    //classThreadA.Start();


    //ThreadB::Counting为非static函数，不可直接调用，需创建Thread对象，使其作为参数传入;
    ThreadB classThreadB;
    boost::thread trdD( boost::bind( &ThreadB::Counting, &classThreadB, 56 ) );

    //当前线程睡眠;
    boost::this_thread::sleep( boost::posix_time::milliseconds( 500 ) );

    system("pause");
    return 0;
}