使用boost::thread跨平台多线程 (二) 线程同步-互斥

原创 2007年09月20日 18:24:00

使用boost::thread跨平台多线程 (二) 线程同步-互斥

作者: 江淼
Blog: http://blog.csdn.net/jiangfriend
时间: 2007-9-20 18:19

在线程同步中有一个很重要元素,互斥体-Mutex,但互斥往往因设计上的疏乎而陷入了死锁。
在boost中同样提供了各种mutex,并尽可能减少这种死锁的疏乎。 

首先看一下如下未使用原始的例子

//例2-1

#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
using namespace std;



/**
boost的time控制相对比较烦锁一点
*/
void sleep(int ms)

    {
    boost::xtime xt;
    boost::xtime_get(&xt,boost::TIME_UTC);
    xt.nsec += ms%1000*1000*1000;
    xt.sec += ms/1000;
    boost::thread::sleep(xt);
    }

struct Run
    {
    bool running;
    string str;
    Run(const string& str):running(false),str(str)
        {
        }
    void loop(void)
        {
        running=true;
        while(running)
            {
            cout<<str<<endl;
            ::sleep(250);
            }
        }
    void stop(void)
        {
        running=false;
        }
    virtual ~Run(void)
        {
        cout<<str<<" "<<__FUNCTION__<<endl;
        }
    };

int main(int argc,char* argv[])
    {
    Run hello("hello");
    Run world("world");
    boost::thread_group grp;
    grp.create_thread(boost::bind(&Run::loop,boost::ref(hello))); //bind hello.loop
    grp.create_thread(boost::bind(&Run::loop,boost::ref(world)));//bind world.loop
    string str;
    getline(cin,str);
    hello.stop(); //停止hello
    world.stop(); //停止world
    grp.join_all(); //等待所有线程确实已结束
    return 0;
    }


因stream的原因本应输出的 Hello/nWorld/n 部分变成了
helloworld

helloworld


world Run::~Run
hello Run::~Run
要如何才能解决这个问题?那就是mutex。
先认识一下boost提共的mutex

2.Mutex

头文件<boost/thread/mutex.hpp>

namespace boost {
  class mutex;
  class try_mutex;
  class timed_mutex;
}
顾名思义,三者分别为,常规mutex,尝试mutex,时间mutex
而mutex本身不能调用成员函数,而是由lock_ops进行控制.
对应现有的几个mutex导入了scoped_lock,scoped_try_lock,scoped_timed_lock.
scoped系列的特色就是析构时解锁,默认构造时加锁,这就很好的确定在某个作用域下某线程独占某段代码。

我们对例2-1 Run::loop进行部分改进。
1. mutex+scoped_lock
    void loop(void)
        {
        running=true;
        while(running)
            {
            typedef boost::mutex MUTEX;
            typedef MUTEX::scoped_lock LOCK;
            static MUTEX iomutex;
                {
                LOCK lock(iomutex);//锁定mutex
                cout<<str<<endl;
                }//lock析构,iomutex解锁
            ::sleep(250);
            }
        }

运行后,意料之中,正常的输出
hello
world
world
hello
world

world Run::~Run
hello Run::~Run
2. try_mutex+scoped_try_lock
    void loop(void)
        {
        running=true;
        while(running)
            {
            typedef boost::try_mutex MUTEX;
            typedef MUTEX::scoped_try_lock LOCK;
            static MUTEX iomutex;
                {
                LOCK lock(iomutex);//锁定mutex
                if(lock.locked())
                    {
                    cout<<str<<endl;
                    }
                else
                    {
                    // To do
                    boost::thread::yield(); //释放控制权
                    continue;
                    }
                }//lock析构,iomutex解锁
            ::sleep(250);
            }
        }
3. timed_mutex+scoped_timed_mutex
    void loop(void)
        {
        running=true;
        while(running)
            {
            typedef boost::timed_mutex MUTEX;
            typedef MUTEX::scoped_timed_lock LOCK;
            static MUTEX iomutex;
                {
                boost::xtime xt;
                boost::xtime_get(&xt,boost::TIME_UTC);
                xt.sec+=1;//超时时间1秒
                LOCK lock(iomutex,xt);//锁定mutex
                cout<<lock.locked()<<" "<<str<<endl;
                ::sleep(10000); //长时间
                }//lock析构,iomutex解锁
            ::sleep(250);
            }
        }
输出:
1 hello
(1秒后)
0 world //超时自动解锁且继续运行

4. mutex+lock
    void loop(void)
        {
        running=true;
        while(running)
            {
            typedef boost::mutex MUTEX;
            typedef boost::detail::thread::lock_ops<MUTEX> LOCK;
            static MUTEX iomutex;
                {
                LOCK::lock(iomutex);
                cout<<str<<endl;
                LOCK::unlock(iomutex);               
                }
            ::sleep(250);
            }
        }
以上就是boost::mutex的用法。

相关链接:

boost官方网站 http://www.boost.org
boost::thread 帮助文档 http://www.boost.org/doc/html/thread.html

Boost 线程同步机制

Boost.Thread.Synchronization Boost 中,可以使用互斥(mutex)变量来进行同步, 通过锁(Lock)操作来获得mutex的所有权,通过解锁(Unlock)操...
  • lzx1104
  • lzx1104
  • 2011年09月09日 14:08
  • 5857

boost线程同步

boost线程同步 教程 l  内锁 l  外锁 除了C++11标准提供的锁,boost.thread提供了其他额外的锁和工具。 内锁: 考虑一个银行账户class,该class提供存款和取款从不同的...
  • a627088424
  • a627088424
  • 2016年01月22日 22:03
  • 1233

Boost.thread 同步锁详解

参考  http://patmusing.blog.163.com/blog/static/1358349602010183920489/
  • muyuxuebao
  • muyuxuebao
  • 2016年03月16日 12:55
  • 825

多线程锁:跨平台 C/C++

一、跨平台锁文件:manual_lock.h //////////////////////////////////////////////////////////////// // //Descri...
  • kanguolaikanguolaik
  • kanguolaikanguolaik
  • 2013年12月18日 14:33
  • 1770

Boost::Thread使用示例

(1)最简单方法#include #include boost::mutex io_mutex; void hello() { std::cout
  • zhuxiaoyang2000
  • zhuxiaoyang2000
  • 2011年07月06日 14:48
  • 42609

boost库读写锁与互斥锁的用法解析

#include #include #include typedef boost::shared_mutex WR_Mutex; typedef boost::unique...
  • qingzai_
  • qingzai_
  • 2015年03月10日 11:33
  • 2677

c++的boost库多线程(Thread)编程(线程操作,互斥体mutex,条件变量)详解

c++的boost库多线程(Thread)编程(线程操作,互斥体mutex,条件变量)详解   分享到: 0     发布时间:2014-4-7      ...
  • xingzheouc
  • xingzheouc
  • 2015年09月21日 23:32
  • 561

Boost::thread库的使用

概要 通过实例介绍boost thread的使用方式,本文主要由线程启动、Interruption机制、线程同步、等待线程退出、Thread Group几个部份组成。 正文 线程...
  • yockie
  • yockie
  • 2013年06月26日 19:32
  • 7136

通过boost::bind实现c++多线程

一.头文件 #include "Runable.h" #include class Production : public Runable { public: Production(); ~...
  • u013354805
  • u013354805
  • 2015年08月13日 14:36
  • 1542

【C++多线程编程】Boost线程库

Boost线程库 Bill Kempf 译:伐木工 标准C++线程即将到来。CUJ预言它将衍生自Boost线程库,现在就由Bill带领我们探索一下Boost线程库。 就...
  • yockie
  • yockie
  • 2014年05月26日 00:31
  • 8313
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章: 使用boost::thread跨平台多线程 (二) 线程同步-互斥
举报原因:
原因补充:

(最多只允许输入30个字)