boost---thread 编程指南(3分钟学会)

合集下载

boost的编译使用

boost的编译使用

boost的编译使用Boost是一个流行的C++库,它提供了许多功能强大的工具和组件,包括容器、算法、并发编程、图形学、网络编程等。

要使用Boost库,首先需要下载并安装Boost库,然后在编译和链接你的C++程序时包含相应的Boost头文件和链接Boost库文件。

下面我将从编译和使用Boost库的角度来详细介绍。

1. 下载和安装Boost库。

首先,你需要从Boost官方网站下载最新的Boost库源代码。

然后,解压缩文件并按照官方文档中的指导进行安装。

通常情况下,Boost提供了一个名为bootstrap.bat(Windows)或者bootstrap.sh(Linux)的脚本,你可以运行这个脚本来配置Boost 库。

接着,运行b2命令来编译Boost库。

2. 编译和链接Boost库。

一旦Boost库安装完成,你就可以在你的C++程序中使用它了。

在编译你的程序时,确保你的编译器能够找到Boost库的头文件。

你可以使用编译器的命令行选项或者在你的IDE中配置头文件搜索路径。

在链接你的程序时,确保你的编译器能够找到Boost库文件。

你需要指定Boost库文件的路径和库名字,具体的方法取决于你使用的编译器和操作系统。

3. 使用Boost库。

一旦你的程序成功编译和链接了Boost库,你就可以在你的代码中包含相应的Boost头文件,并使用Boost提供的功能和组件了。

比如,如果你想使用Boost的智能指针,你可以包含<boost/shared_ptr.hpp>头文件,并使用boost::shared_ptr类来管理动态分配的对象。

总之,要使用Boost库,你需要下载、安装Boost库,配置你的编译器,包含Boost头文件,链接Boost库文件,并在你的代码中使用Boost提供的功能和组件。

希望这些信息能够帮助你成功地编译和使用Boost库。

boost-机器学习与深度学习入门-黄海广博士整理PPT

boost-机器学习与深度学习入门-黄海广博士整理PPT
特征增益的均值 特征分裂时的平均覆盖样本数
线性特征生成
new_feature= model.apply(X_train)
大学
谢谢!
x<4.5
8.95
x<3.5
6.83Βιβλιοθήκη x<2.56.56
5.63
5.82
机器学习基础-Gradient boosting Tree
损失函数的负梯度在当前模型的 值作为提升树的残差的近似值来 拟合回归树
机器学习基础-Gradient boosting Tree
机器学习基础-XGBoost
机器学习基础-XGBoost
机器学习基础-集成学习
Stacking
将训练好的所有基模型对训 练基进行预测,第j个基模型 对第i个训练样本的预测值将 作为新的训练集中第i个样本 的第j个特征值,最后基于新 的训练集进行训练。同理, 预测的过程也要先经过所有 基模型的预测形成新的测试 集,最后再对测试集进行预 测。
机器学习基础-Boosting Tree
C为常数,J为叶子节点
机器学习基础-Boosting Tree
前向分步算法:
机器学习基础-Boosting Tree
机器学习基础-Boosting Tree
s
1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5 9.5
m(s) 15.72 12.07 8.36 5.78 3.91 1.93 8.01 11.73 15.74
xx研究院
机器学习与深度学习入门
黄海广
2019年6月
机器学习基础-决策树


长相
不帅
家庭背景

不好

脚本精灵函数说明

脚本精灵函数说明

目录1 脚本精灵控制条 (7)1.1 改变控制条状态 (7)1.1.1 展开态 (7)1.1.2 缩放态 (8)1.1.3 吸附态 (8)1.2 脚本管理 (9)1.2.1 二进制脚本 (11)1.2.1 明文脚本 (12)1.2.3 导入脚本 (13)1.2.4 退出脚本管理面板 (14)1.3 播放脚本 (14)1.3.1 开始播放 (14)1.3.2 播放一次 (14)1.3.3 循环播放 (15)1.3.4 停止播放 (15)1.4 录制脚本 (15)1.4.1 开始录制 (15)1.4.2 停止录制 (16)1.4.3 保存脚本 (16)1.5 取素材 (16)1.5.1 全屏截图 (16)2 脚本精灵开发工具 (19)2.1 基本介绍 (19)2.1.1 开发工具介绍 (19)2.1.2 各组成部分介绍 (19)2.1.3 二进制脚本结构 (19)2.1.4 明文格式脚本 (20)2.2 工程管理 (20)2.2.2 删除工程 (21)2.2.3 脚本编辑 (21)2.2.4 图片路径 (21)2.3 远程设备管理 (21)2.3.1 远程导入脚本 (22)2.3.2 远程屏幕 (22)2.3.3 远程截图 (22)2.3.4 远程取色 (23)2.3.5 远程取坐标 (23)2.4 脚本编辑器 (23)2.4.1 关键字高亮 (23)2.4.2 脚本检错 (24)2.4.3 编译脚本 (24)3 脚本语言 (25)4 脚本精灵库函数 (27)4.1 基本函数 (27)4.1.1 触摸点击 (27)4.1.2 触摸按下 (27)4.1.3 触摸弹起 (28)4.1.4 触摸滑动 (29)4.1.5 输入文本 (30)4.1.6 模拟按键 (31)4.1.7 获取颜色 (31)4.1.8 普通寻色 (32)4.1.9 模糊寻色 (33)4.1.10 RGB颜色合成 (34)4.1.11 获取颜色RGB (35)4.1.12 判断颜色 (36)4.1.13 精确寻图 (37)4.1.14 点击图片 (38)4.1.15 范围寻图 (39)4.1.16 模糊寻图 (40)4.1.17 范围模糊寻图 (41)4.1.18 不规则寻图 (43)4.1.19 范围不规则寻图 (44)4.1.24 获取屏幕色位 (49)4.1.25 弹出文本提示 (50)4.1.26 震动 (51)4.1.27 记录日志 (51)4.1.28 记录错误日志 (52)4.1.29 查找某应用是否安装 (53)4.1.30 判断某应用是否正在运行 (54)4.1.31 启动指定应用 (55)4.1.32 结束一个应用 (56)4.1.33 退出当前脚本 (56)4.1.34 获取SD卡路径 (57)4.1.35 截图到文件 (58)4.1.36 拷贝文本到剪切板 (59)4.1.37 暂停指定应用 (60)4.1.38 恢复指定应用的运行 (60)4.2 高级函数 (61)4.2.1 获取设备UDID唯一串 (61)4.2.2 获取网卡MAC (62)4.2.3 获取蓝牙设备MAC (63)4.2.4 获取IMEI (64)4.2.5 获取设备信息串 (65)4.2.9 随机触摸滑动 (70)4.2.10 http访问 (71)4.3 兼容模式相关函数 (71)4.3.1 强制设置兼容模式 (72)4.3.2 判断当前模式 (72)4.3.3 设置自定义截屏 (74)4.3.4 截取屏幕 (74)5 使用技巧 (77)5.1 如何模拟触摸操作 (77)5.2 如何寻图 (77)5.3 如何找色 (78)5.4 如何记录日志 (78)5.5 开发平台如何与手机建立连接 (78)5.6 如何进行远程调试 (78)5.7 如何输入中文文本 (79)5.8 脚本优化原则 (79)5.9 处理意外逻辑 (79)6 附录 (82)6.1 虚拟键对照表 (82)7 UI说明 (84)7.1脚本结构 (84)7.6创建文本编辑框 (87)7.7创建复选框 (88)7.8创建单选框 (88)7.9创建按钮 (89)7.10 UI换行 (90)7.11创建扩展窗口 (90)7.12在扩展窗口中创建控件 (90)7.13动态设置UI文本 (91)7.14动态获取UI文本 (92)7.15动态设置选中 (92)7.16动态获取选择状态 (92)7.17设置是否显示循环播放设置UI (93)8、获取配置项 (94)1 脚本精灵控制条为方便使用,脚本精灵所有的功能都集中在控制条上,控制条可任意拖动,缩小,吸附。

rt-thread入门指南

rt-thread入门指南

时间。 此外还有其他的一些编程模型, 比如定义一个函数指针数组, 然后将各个模块代码各自 写成函数, 向函数指针数组中填充模块的函数指针, 这种编程的方式实际是轮询式编程的一 种变形。因为不支持抢占,所以还是轮询的方式,并没有从根本上解决轮询的弊端。 当系统中各个部分复杂起来, 各种控制逻辑相互交织的时候, 编写一个清晰的裸机程序 会耗费一些脑细胞, 尤其是当代码量增长到数千行至上万行时, 如果没有一个合理并且清晰 的程序结构,问题会更糟糕。 让我们来考虑一下桌面系统,比如大名鼎鼎的 windows-XP,这是一个多任务的操作 系统, 每个应用程序各自工作, 它们并不知道其它应用程序处于什么状态, 是运行还是关闭, 每个应用程序仿佛占用了整个 CPU 一样,由操作系统管理多个应用程序的运行,套用伟大 的政治课本上的一句伟大的名言,这极大的解放了我们的生产力。采用 RTOS,多个人可以 为多个模块各自编写代码。每个任务占用一个线程,任务在线程中活动,最简单的情况下, 它可以不知道其它线程的状态。这种方式,无疑可以大大加快程序的编写,并且减轻程序拼 装的难度。RTOS 接管了最令人头痛的环节。 在嵌入式系统中,显然不能运行桌面操作系统,在这种情况下,嵌入式操作系统横空出 世。在嵌入式领域,主要使用的嵌入式系统都是实时嵌入式系统,故了描述方便,下面称之 为 RTOS。下一节我将隆重介绍国产实时嵌入式系统 RT-Thread。
让我们来考虑一下桌面系统比如大名鼎鼎的windowsxp这是一个多任务的操作系统每个应用程序各自工作它们并不知道其它应用程序处于什么状态是运行还是关闭每个应用程序仿佛占用了整个cpu一样由操作系统管理多个应用程序的运行套用伟大的政治课本上的一句伟大的名言这极大的解放了我们的生产力
目录
0 裸机编程引发的思考........................................................................................................... 2 1 Rt-hread 简介 ........................................................................................................................ 6 1.1 RT-Thread 内核 ................................................................................................... 6 1.2 RT-Thread 与 µC/OS-II 对比................................................................................ 7 1.3 支持平台............................................................................................................. 7 1.4 获取 RT-Thread 最新动态,寻求帮助 .............................................................. 8 2 RT-Thread 应用开发 .............................................................................................................. 9 2.1 第一个应用 流水灯......................................................................................... 9 仿真运行......................................................................................................... 15 开发板上实际运行 ......................................................................................... 16

BOOST线程完全攻略

BOOST线程完全攻略

BOOST线程完全攻略1 创建线程⾸先看看boost::thread的构造函数吧,boost::thread有两个构造函数:(1)thread():构造⼀个表⽰当前执⾏线程的线程对象;(2)explicit thread(const boost::function0& threadfunc):boost::function0可以简单看为:⼀个⽆返回(返回void),⽆参数的函数。

这⾥的函数也可以是类重载operator()构成的函数;该构造函数传⼊的是函数对象⽽并⾮是函数指针,这样⼀个具有⼀般函数特性的类也能作为参数传⼊,在下⾯有例⼦。

第⼀种⽅式:最简单⽅法void hello(){std::cout <<"Hello world, I''m a thread!"<< std::endl;}int main(int argc, char* argv[]){boost::thread thrd(&hello);thrd.join();return0;}第⼆种⽅式:复杂类型对象作为参数来创建线程:boost::mutex io_mutex;struct count{count(int id) : id(id) { }void operator()(){for (int i = 0; i < 10; ++i){boost::mutex::scoped_locklock(io_mutex);std::cout << id << ": "<< i << std::endl;}}int id;};int main(int argc, char* argv[]){boost::thread thrd1(count(1));boost::thread thrd2(count(2));thrd1.join();thrd2.join();return0;}第三种⽅式:在类内部创建线程;class HelloWorld{public:static void hello(){std::cout <<"Hello world, I''m a thread!"<< std::endl;}static void start(){boost::thread thrd( hello );thrd.join();}};int main(int argc, char* argv[]){HelloWorld::start();return0;}在这⾥start()和hello()⽅法都必须是static⽅法。

C++的boost库的编译安装

C++的boost库的编译安装

ICU编译(VS2010):ICU提供了unicode和国际化支持,目前的版本是 4.8.1。

ICU的主页是/。

(1). 下载可以从/projects/icu/files/下载源代码版本。

4.8.1是VS2010的,4.4.2才是VS2008的,如果是2010要做转换。

(2). 编译ICU的编译比较简单,打开ICU源代码目录下的source\allinone\allinone.sln,需要转换到VS2008格式,直接转换即可。

然后,选择release,Rebuild Solution即可。

(3). 测试将编译出来的bin目录加入到系统的PATH目录中去。

然后,重新打开allinone.sln工程。

需要通过测试的项目1. cintltst项目2. intltest项目3. iotest分别设置成启动项目,运行即可。

2. bzipbzip的主页是/,从/downloads.html下面下载源代码包即可,boost直接使用源代码来进行编译。

3. zlibzlib的主页是/,/projects/gnuwin32/files/zlib/从该网页下面下载源代码包即可,boost直接使用源代码来进行编译。

4. pythonpython的主页是/,下载python的2.5.2版本,安装即可。

boost默认是会编译python,并且会自动寻找python的安装目录。

ICU编译(MinGW):还未成功编译第一步:到官网,下载boost最新版boost_1_47_0.zip第二步:将boost压缩包解压到C盘根目录下(在C盘操作简单,不会出错),目录为C:\BOOST_1_47_0,里面就是boost的源码和需要编译的文件及文档资料第三步:用打开一个cmd命令窗口,在C:\Program Files\Microsoft Visual Studio 10.0\VC\bin目录下找到VCVARS32.bat,拖到cmd命令窗口,按回车第四步:将cmd中的目录跳转到C:/boost_1_47_0/tools/build/v2下,拖动bootstrap.bat批处理文件到cmd,,按回车键,随即就会在C:/boost_1_47_0/tools/build/v2下生产一个bjam.exe和b2.exe。

boost之ThreadPool

boost之ThreadPool

pool_adaptors.hpp
对全局schedule函数的几种封装。
future.hpp
好像thread子库也有future,但不清楚是否是一样的内容。
threadpool的future是为了封装异步函数调用返回值实现的。
简单点理解,就是schedule任务的时候,把一个指针在两者间绑定起来,后面就可以通过future来获取返回值了。
//worker_thread的run函数
void run()
{
scope_guard notify_exception(bind(&amp;worker_thread::died_unexpectedly, this));
while(m_pool-&gt;execute_task()) {} //loop直到返回值为false
pool tp(2);
// Add some tasks to the pool.
tp.schedule(&amp;first_task);
tp.schedule(&amp;second_task);
// Wait until all tasks are finished.
if(worker)
{
//run是线程的loop函数
worker-&gt;m_thread.reset(new boost::thread(bind(&amp;worker_thread::run, worker)));
}
}
view plaincopy to clipboardprint?
当然,获取返回值的过程应该是阻塞的,任务未完成时只能wait。

boost之threadpool(提高之线程池)

boost之threadpool(提高之线程池)

boost之threadpool(提高之线程池)提高之threadpoolboost之线程池线程池是基于升压库实现的一个线程池子库,但线程池实现起来不是很复杂。

我们从线程池中又能学到什么东西呢?它是基于升压库实现的,如果大家对升压库有兴趣,看看一个简单的实现还是可以学到点东西的。

线程池基本功能1、任务封装,包括普通任务(task_func)和优先级任务(prio_task_func)。

2、调度策略,包括fifo_scheduler(先进先出)、lifo_scheduler (后进先出)、prio_scheduler(优先级)。

3、结束策略,包括wait_for_all_tasks(全部任务等待)、wait_for_active_tasks(激活任务等待)、立即(立即结束)。

4、动态修改线程池个数功能。

5、基于未来封装的异步返回值获取功能。

在sorceforge上有一个用升压编写的线程池。

该线程池和升压结合的比较好,并且提供了多种任务执行策略,使用也非常简单。

下载地址:/这个线程池不需要编译,只要在项目中包含其头文件就可以了。

一、源代码分析快速入门分析(/线程池线程池/快速/库/)这个例子的代码很简单,但已经全部展示了线程池的核心内容,包括建立、调度、同步等操作。

查看plaincopy到clipboardprint?//创建FIFO线程池容器用两个线程。

池TP(2);/向池中添加一些任务。

TP。

时间表(&amp;first_task);TP。

时间表(&amp;second_task);/等待所有任务完成。

wait() TP;//创建FIFO线程池容器用两个线程。

池TP(2);/向池中添加一些任务。

TP。

时间表(&amp;first_task);TP。

时间表(&amp;second_task);/等待所有任务完成。

wait() TP;池的定义具体见池。

HPP,但使用了pimpl模式,核心代码见pool_core HPP文件。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

0 前言标准C++线程即将到来。

CUJ预言它将衍生自Boost线程库,现在就由Bill带领我们探索一下Boost线程库。

就在几年前,用多线程执行程序还是一件非比寻常的事。

然而今天互联网应用服务程序普遍使用多线程来提高与多客户链接时的效率;为了达到最大的吞吐量,事务服务器在单独的线程上运行服务程序;GUI应用程序将那些费时,复杂的处理以线程的形式单独运行,以此来保证用户界面能够及时响应用户的操作。

这样使用多线程的例子还有很多。

但是C++标准并没有涉及到多线程,这让程序员们开始怀疑是否可能写出多线程的C++程序。

尽管不可能写出符合标准的多线程程序,但是程序员们还是会使用支持多线程的操作系统提供的多线程库来写出多线程C++程序。

但是这样做至少有两个问题:这些库大部分都是用C语言完成的,如果在C++程序中要使用这些库就必须十分小心;还有,每一个操作系统都有自己的一套支持多线程的类库。

因此,这样写出来得代码是没有标准可循的,也不是到处都适用的(non- portable)。

Boost线程库就是为了解决所有这些问题而设计的。

Boost是由C++标准委员会类库工作组成员发起,致力于为C++开发新的类库的组织。

现在它已经有近2000名成员。

许多库都可以在Boost源码的发布版本中找到。

为了使这些类库是线程安全的(thread-safe),Boost线程库被创建了。

许多C++专家都投身于Boost线程库的开发中。

所有接口的设计都是从0开始的,并不是C线程API的简单封装。

许多C++特性(比如构造函数和析构函数,函数对象(function object)和模板)都被使用在其中以使接口更加灵活。

现在的版本可以在POSIX,Win32和Macintosh Carbon平台下工作。

1 创建线程就像std::fstream类就代表一个文件一样,boost::thread类就代表一个可执行的线程。

缺省构造函数创建一个代表当前执行线程的实例。

一个重载的构造函数以一个不需任何参数的函数对象作为参数,并且没有返回值。

这个构造函数创建一个新的可执行线程,它调用了那个函数对象。

起先,大家认为传统C创建线程的方法似乎比这样的设计更有用,因为C创建线程的时候会传入一个void*指针,通过这种方法就可以传入数据。

然而,由于Boost线程库是使用函数对象来代替函数指针,那么函数对象本身就可以携带线程所需的数据。

这种方法更具灵活性,也是类型安全(type-safe) 的。

当和Boost.Bind这样的功能库一起使用时,这样的方法就可以让你传递任意数量的数据给新建的线程。

目前,由Boost线程库创建的线程对象功能还不是很强大。

事实上它只能做两项操作。

线程对象可以方便使用==和!=进行比较来确定它们是否是代表同一个线程;你还可以调用boost::thread::join来等待线程执行完毕。

其他一些线程库可以让你对线程做一些其他操作(比如设置优先级,甚至是取消线程)。

然而,由于要在普遍适用(portable)的接口中加入这些操作不是简单的事,目前仍在讨论如何将这些操组加入到Boost线程库中。

Listing1展示了boost::thread类的一个最简单的用法。

新建的线程只是简单的在std::out上打印“hello,world”,main函数在它执行完毕之后结束。

例1:1.#include <boost/thread/thread.hpp>2.#include <iostream>3.4.void hello()5.{6. std::cout <<7. "Hello world, I'm a thread!"8. << std::endl;9.}10.11.int main(int argc, char* argv[])12.{13. boost::thread thrd(&hello);14. thrd.join();15. return 0;16.}复制代码2 互斥体任何写过多线程程序的人都知道避免不同线程同时访问共享区域的重要性。

如果一个线程要改变共享区域中某个数据,而与此同时另一线程正在读这个数据,那么结果将是未定义的。

为了避免这种情况的发生就要使用一些特殊的原始类型和操作。

其中最基本的就是互斥体(mutex,mutual exclusion的缩写)。

一个互斥体一次只允许一个线程访问共享区。

当一个线程想要访问共享区时,首先要做的就是锁住(lock)互斥体。

如果其他的线程已经锁住了互斥体,那么就必须先等那个线程将互斥体解锁,这样就保证了同一时刻只有一个线程能访问共享区域。

互斥体的概念有不少变种。

Boost线程库支持两大类互斥体,包括简单互斥体(simple mutex)和递归互斥体(recursive mutex)。

如果同一个线程对互斥体上了两次锁,就会发生死锁(deadlock),也就是说所有的等待解锁的线程将一直等下去。

有了递归互斥体,单个线程就可以对互斥体多次上锁,当然也必须解锁同样次数来保证其他线程可以对这个互斥体上锁。

在这两大类互斥体中,对于线程如何上锁还有多个变种。

一个线程可以有三种方法来对一个互斥体加锁:1. 一直等到没有其他线程对互斥体加锁。

2. 如果有其他互斥体已经对互斥体加锁就立即返回。

3. 一直等到没有其他线程互斥体加锁,直到超时。

似乎最佳的互斥体类型是递归互斥体,它可以使用所有三种上锁形式。

然而每一个变种都是有代价的。

所以Boost线程库允许你根据不同的需要使用最有效率的互斥体类型。

Boost线程库提供了6中互斥体类型,下面是按照效率进行排序:1.boost::mutex,2.boost::try_mutex,3.boost::timed_mutex,4.boost::recursive_mutex,5.boost::recursive_try_mutex,6.boost::recursive_timed_mutex复制代码如果互斥体上锁之后没有解锁就会发生死锁。

这是一个很普遍的错误,Boost线程库就是要将其变成不可能(至少时很困难)。

直接对互斥体上锁和解锁对于 Boost线程库的用户来说是不可能的。

mutex类通过teypdef定义在RAII中实现的类型来实现互斥体的上锁和解锁。

这也就是大家知道的 Scope Lock模式。

为了构造这些类型,要传入一个互斥体的引用。

构造函数对互斥体加锁,析构函数对互斥体解锁。

C++保证了析构函数一定会被调用,所以即使是有异常抛出,互斥体也总是会被正确的解锁。

这种方法保证正确的使用互斥体。

然而,有一点必须注意:尽管Scope Lock模式可以保证互斥体被解锁,但是它并没有保证在异常抛出之后贡献资源仍是可用的。

所以就像执行单线程程序一样,必须保证异常不会导致程序状态异常。

另外,这个已经上锁的对象不能传递给另一个线程,因为它们维护的状态并没有禁止这样做。

List2给出了一个使用boost::mutex的最简单的例子。

例子中共创建了两个新的线程,每个线程都有10次循环,在std::cout上打印出线程id和当前循环的次数,而main函数等待这两个线程执行完才结束。

std::cout就是共享资源,所以每一个线程都使用一个全局互斥体来保证同时只有一个线程能向它写入。

许多读者可能已经注意到List2中传递数据给线程还必须的手工写一个函数。

尽管这个例子很简单,如果每一次都要写这样的代码实在是让人厌烦的事。

别急,有一种简单的解决办法。

函数库允许你通过将另一个函数绑定,并传入调用时需要的数据来创建一个新的函数。

List3向你展示了如何使用Boost.Bind库来简化List2中的代码,这样就不必手工写这些函数对象了。

例2:1.#include <boost/thread/thread.hpp>2.#include <boost/thread/mutex.hpp>3.#include <iostream>4.5.boost::mutex io_mutex;6.7.struct count8.{9. count(int id) : id(id) { }10.11. void operator()()12. {13. for (int i = 0; i < 10; ++i)14. {15. boost::mutex::scoped_lock16. lock(io_mutex);17. std::cout << id << ": "18. << i << std::endl;19. }20. }21.22. int id;23.};24.25.int main(int argc, char* argv[])26.{27. boost::thread thrd1(count(1));28. boost::thread thrd2(count(2));29. thrd1.join();30. thrd2.join();31. return 0;32.}复制代码例3: // 这个例子和例2一样,除了使用Boost.Bind来简化创建线程携带数据,避免使用函数对象1.#include <boost/thread/thread.hpp>2.#include <boost/thread/mutex.hpp>3.#include <boost/bind.hpp>4.#include <iostream>5.6.boost::mutex io_mutex;7.8.void count(int id)9.{10. for (int i = 0; i < 10; ++i)11. {12. boost::mutex::scoped_lock13. lock(io_mutex);14. std::cout << id << ": " <<15. i << std::endl;16. }17.}18.19.int main(int argc, char* argv[])20.{21. boost::thread thrd1(22. boost::bind(&count, 1));23. boost::thread thrd2(24. boost::bind(&count, 2));25. thrd1.join();26. thrd2.join();27. return 0;28.}复制代码3 条件变量有的时候仅仅依靠锁住共享资源来使用它是不够的。

相关文档
最新文档