使用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线程同步 教程 l  内锁 l  外锁 除了C++11标准提供的锁,boost.thread提供了其他额外的锁和工具。 内锁: 考虑一个银行账户class,该class提供存款和取款从不同的...

Boost 线程同步机制

Boost.Thread.Synchronization Boost 中,可以使用互斥(mutex)变量来进行同步, 通过锁(Lock)操作来获得mutex的所有权,通过解锁(Unlock)操...

boost::asio::io_service和io_service::work和boost::thread_group配合使用

学习boost的 //注释中的Page是指:Boost程序库完全开发指南(第三版) #include //Page542: 在头文件前定义此宏,它就会向标准流cerr输出运行日志。 //#defin...

使用boost::thread跨平台多线程 (一) 基本使用

使用boost::thread跨平台多线程 (一) 基本使用 作者: 江淼 Blog: http://blog.csdn.net/jiangfriend 时间: 2007-9-12 00:31 关于b...

Boost::thread库的使用

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

java多线程Thread线程同步与互斥、锁机制

Thread安全线程安全不是指数据本身或者数据传输中的安全,而主要是指在高并发多线程的访问过程中,多线程对数据本身的读写所造成的数据不一致、脏数据等情况的避免。在多线程运行过程中,需要保持各个线程之间...

C#Thread类多线程系列之(三)线程同步技术

线程同步     单线程,每次只能做一件事,多线程,就会发生两个线程抢占资源的问题,编程时需要防止这些资源的访问冲突。为此,C#提供了线程同步机制来防止资源访问的冲突。 线程同步机制,是指线程高效...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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