BOOST之Thread库学习

//Boost并发编程之thread

}

cond_get.wait(mu);

}

--unread;

*x = stk.front();

stk.pop();

}

cond_put.notify_one();

}

template<typename T>

void DataBuffer<T>::get(const T& x)

{

{

mutex::scoped_lock lock(mu);

while (is_full())

{

{

}

cond_put.wait(mu);

}

stk.push(x);

++unread;

}

cond_get.notify_one();

}

template<typename T>

DataBuffer<T>::~DataBuffer()

{

}

-------------------------------------------------------------共享互斥变量

共享互斥量shared_mutex不同于mutex和recursive_mutex,它允许线程获取多个共享所有权和一个专享所有权实现了读写锁机制

如果要获取共享权的使用需调用lock_shared()或者try_lock_shared()，相应的使用unlock_shared来释放所有权

shared_mutex么有提供内部的lock_guard类型定义因此必须直接使用lock_guard对象

读锁定时使用shared_lock<shared_mutex>,写锁定时使用unique_lock<shared_mutex>

--------------------------------------------------使用

------------------------------------------future

thread库使用future范式提供一种异步操作线程返回值的方法因为这个返回值在线程开始执行时还是不可用的

packaged_task和promise两个模板类来包装异步调用，用unique_future和shared_future来获取异步调用结果

------------------packaged_task好像是一个reference_wrapper 或者function对象，它提供opertor()包装一个可回调物然后就可以被任意线程调用最后future值可以用成员函数get_future()获得

unique_future 用来存储packaged_task异步计算的future值，他只能持有唯一的一个引用

----------------------使用方法：

int fab(int n)//递归计算斐波那契数列

{

}

*/

#include<boost\thread.hpp>

#include<iostream>

using namespace std;

using namespace boost;

int fab(int n)//递归计算斐波那契数列

{

if (n == 0 || n == 1)

{

return 1;

}

return fab(n - 1) + fab(n - 2);

}

int main()

{

packaged_task<int>pt(bind(fab,30));//声明packaged_task对象用模板参数指明返回值的类型packaged_task只接受无参函数因此需要bind

unique_future<int> uf = pt.get_future();//声明unqiue_future对象接受packaged_task的future值 同样使用模板参数指明返回类型

thread(boost::move(pt));//启动线程计算必须使用boost::move()来转移pack_task对象因为packaged_task是不可拷贝的

uf.wait();//uf等待计算结果

assert(uf.is_ready() && uf.has_value());

cout << uf.get() << endl;

}