本文详细介绍了Boost线程库的基本使用方法，包括线程的创建、互斥体、条件变量等核心概念，并通过实例展示了如何利用Boost线程库进行多线程编程。
创建线程
头文件 <boost/thread/thread.hpp>
namespace boost {
class thread;
class thread_group;
}
thread()：构造一个表示当前执行线程的线程对象
explicit thread(const boost::function0<void>& threadfunc)
注：boost::function0<void>可以简单看为：一个无返回(返回void)，无参数的函数。这里的函数也可以是类重载operator()构成的函数。
//第一种方式：最简单方法
#include <boost/thread/thread.hpp>
#include <iostream>
void hello()
{
std::cout <<
"Hello world, I''m a thread!"
<< std::endl;
}
int main(int argc, char* argv[])
{
boost::thread thrd(&hello);
thrd.join();
return 0;
}
//第二种方式：复杂类型对象作为参数来创建线程
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <iostream>
boost::mutex io_mutex;
struct count
{
count(int id) : id(id) { }
void operator()()
{
for (int i = 0; i < 10; ++i)
{
boost::mutex::scoped_lock
lock(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();
return 0;
}
//第三种方式：在类内部创建线程
// （1）类内部静态方法启动线程
#include <boost/thread/thread.hpp>
#include <iostream>
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();
return 0;
}
// 在这里start()和hello()方法都必须是static方法。
// （2）如果要求start()和hello()方法不能是静态方法则采用下面的方法创建线程：
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
class HelloWorld
{
public:
void hello()
{
std::cout <<
"Hello world, I''m a thread!"
<< std::endl;
}
void start()
{
boost::function0< void> f = boost::bind(&HelloWorld::hello,this);
boost::thread thrd( f );
thrd.join();
}
};
int main(int argc, char* argv[])
{
HelloWorld hello;
hello.start();
return 0;
}
// （3）在Singleton模式内部创建线程：
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
class HelloWorld
{
public:
void hello()
{
std::cout <<
"Hello world, I''m a thread!"
<< std::endl;
}
static void start()
{
boost::thread thrd( boost::bind
(&HelloWorld::hello,&HelloWorld::getInstance() ) ) ;
thrd.join();
}
static HelloWorld& getInstance()
{
if ( !instance )
instance = new HelloWorld;
return *instance;
}
private:
HelloWorld(){}
static HelloWorld* instance;
};
HelloWorld* HelloWorld::instance = 0;
int main(int argc, char* argv[])
{
HelloWorld::start();
return 0;
}
//第四种方法：用类内部函数在类外部创建线程
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
#include <string>
#include <iostream>
class HelloWorld
{
public:
void hello(const std::string& str)
{
std::cout <<str<< std::endl;
}
};
int main(int argc, char* argv[])
{
HelloWorld obj;
boost::thread thrd( boost::bind(&HelloWorld::hello,&obj,"Hello
world, I''m a thread!" ) ) ;
thrd.join();
return 0;
}
//如果线程需要绑定的函数有参数则需要使用boost::bind。比如想使用 boost::thread创建一个线程来执行函数：void f(int i)，
//如果这样写：boost::thread thrd(f)是不对的，因为thread构造函数声明接受的是一个没有参数且返回类型为void的型别，而且
//不提供参数i的值f也无法运行，这时就可以写：boost::thread thrd(boost::bind(f,1))。涉及到有参函数的绑定问题基本上都
//是boost::thread、boost::function、boost::bind结合起来使用。
//互斥体
//一个互斥体一次只允许一个线程访问共享区。当一个线程想要访问共享区时，首先要做的就是锁住（lock）互斥体。
//Boost线程库支持两大类互斥体，包括简单互斥体（simple mutex)和递归互斥体（recursive mutex)。
//有了递归互斥体，单个线程就可以对互斥体多次上锁，当然也必须解锁同样次数来保证其他线程可以对这个互斥体上锁。
//Boost线程库提供的互斥体类型：
boost::mutex,
boost::try_mutex,
boost::timed_mutex,
boost::recursive_mutex,
boost::recursive_try_mutex,
boost::recursive_timed_mutex,
boost::shared_mutex
//mutex类采用Scope Lock模式实现互斥体的上锁和解锁。即构造函数对互斥体加锁，析构函数对互斥体解锁。
// 对应现有的几个mutex导入了scoped_lock,scoped_try_lock,scoped_timed_lock.
// scoped系列的特色就是析构时解锁，默认构造时加锁，这就很好的确定在某个作用域下某线程独占某段代码。
//mutex+scoped_lock
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <iostream>
boost::mutex io_mutex;
void count(int id)
{
for (int i = 0; i < 10; ++i)
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << id << ": " << i << std::endl;
}
}
{
boost::thread thrd1(boost::bind(&count, 1));
boost::thread thrd2(boost::bind(&count, 2));
thrd1.join();
thrd2.join();
return 0;
}
//try_mutex+scoped_try_lock
void loop(void)
{
bool running = true;
while (running)
{
static boost::try_mutex iomutex;
{
boost::try_mutex::scoped_try_lock lock(iomutex);//锁定mutex
if (lock.owns_lock())
{
std::cout << "Get lock." << std::endl;
}
else
{
// To do
std::cout << "Not get lock." << std::endl;
boost::thread::yield(); //释放控制权
continue;
}
} //lock析构,iomutex解锁
}
}
//timed_mutex+scoped_timed_mutex
void loop(void)
{
bool 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; //超时时间秒
LOCK lock(iomutex, xt); //锁定mutex
if (lock.owns_lock())
{
std::cout << "Get lock." << std::endl;
}
else
{
std::cout << "Not get lock." << std::endl;
boost::thread::yield(); //释放控制权
}
//::sleep(10000); //长时间
} //lock析构,iomutex解锁
//::sleep(250);
}
}
//shared_mutex
//应用boost::thread的shared_mutex实现singled_write/multi_read的简单例子
#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/shared_mutex.hpp>
using namespace std;
using namespace boost;
boost::shared_mutex shr_mutex;
/// 这个是辅助类，能够保证log_info被完整的输出
class safe_log {
public:
static void log(const std::string& log_info) {
boost::mutex::scoped_lock lock(log_mutex);
cout << log_info << endl;
}
private:
static boost::mutex log_mutex;
};
boost::mutex safe_log::log_mutex;
void write_process() {
shr_mutex.lock();
safe_log::log("begin of write_process");
safe_log::log("end of write_process");
shr_mutex.unlock();
}
void read_process() {
shr_mutex.lock_shared();
safe_log::log("begin of read_process");
safe_log::log("end of read_process");
shr_mutex.unlock_shared();
}
int main() {
thread_group threads;
for (int i = 0; i < 10; ++ i) {
threads.create_thread(&write_process);
threads.create_thread(&read_process);
}
threads.join_all();
::system("PAUSE");
return 0;
}
//条件变量
//有的时候仅仅依靠锁住共享资源来使用它是不够的。有时候共享资源只有某些状态的时候才能够使用。
// 比方说，某个线程如果要从堆栈中读取数据，那么如果栈中没有数据就必须等待数据被压栈。这种情
//况下的同步使用互斥体是不够的。另一种同步的方式－－条件变量，就可以使用在这种情况下。
//boost::condition
typedef condition_variable_any condition;
void wait(unique_lock<mutex>& m);
boost::condition_variable
template<typename lock_type>
void wait(lock_type& m);
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <iostream>
const int BUF_SIZE = 10;
const int ITERS = 100;
boost::mutex io_mutex;
class buffer
{
public:
typedef boost::mutex::scoped_lock scoped_lock;
buffer()
: p(0), c(0), full(0)
{
}
void put(int m)
{
scoped_lock lock(mutex);
if (full == BUF_SIZE)
{
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << "Buffer is full. Waiting..." << std::endl;
}
while (full == BUF_SIZE)
cond.wait(lock);
}
buf[p] = m;
p = (p+1) % BUF_SIZE;
++full;
cond.notify_one();
}
int get()
{
scoped_lock lk(mutex);
if (full == 0)
{
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << "Buffer is empty. Waiting..." << std::endl;
}
while (full == 0)
cond.wait(lk);
}
int i = buf[c];
c = (c+1) % BUF_SIZE;
--full;
cond.notify_one();
return i;
}
private:
boost::mutex mutex;
boost::condition cond;
unsigned int p, c, full;
int buf[BUF_SIZE];
};
buffer buf;
void writer()
{
for (int n = 0; n < ITERS; ++n)
{
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << "sending: " << n << std::endl;
}
buf.put(n);
}
}
void reader()
{
for (int x = 0; x < ITERS; ++x)
{
int n = buf.get();
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << "received: " << n << std::endl;
}
}
}
int main(int argc, char* argv[])
{
boost::thread thrd1(&reader);
boost::thread thrd2(&writer);
thrd1.join();
thrd2.join();
return 0;
}
//线程局部存储
// 函数的不可重入。
//Boost线程库提供了智能指针boost::thread_specific_ptr来访问本地存储线程（thread local storage）。
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/tss.hpp>
#include <iostream>
boost::mutex io_mutex;
boost::thread_specific_ptr<int> ptr;
struct count
{
count(int id) : id(id) { }
void operator()()
{
if (ptr.get() == 0)
ptr.reset(new int(0));
for (int i = 0; i < 10; ++i)
{
(*ptr)++; // 往自己的线程上加
boost::mutex::scoped_lock lock(io_mutex);
std::cout << id << ": " << *ptr << std::endl;
}
}
int id;
};
int main(int argc, char* argv[])
{
boost::thread thrd1(count(1));
boost::thread thrd2(count(2));
thrd1.join();
thrd2.join();
return 0;
}
//仅运行一次的例程
//如何使得初始化工作（比如说构造函数）也是线程安全的。
//“一次实现”（once routine）。“一次实现”在一个应用程序只能执行一次。
//Boost线程库提供了boost::call_once来支持“一次实现”，并且定义了一个标志boost::once_flag及一个初始化这个标志的宏 BOOST_ONCE_INIT。
#include <boost/thread/thread.hpp>
#include <boost/thread/once.hpp>
#include <iostream>
int i = 0;
boost::once_flag flag = BOOST_ONCE_INIT;
void init()
{
++i;
}
void thread()
{
boost::call_once(&init, flag);
}
int main(int argc, char* argv[])
{
boost::thread thrd1(&thread);
boost::thread thrd2(&thread);
thrd1.join();
thrd2.join();
std::cout << i << std::endl;
return 0;
}
扫一扫
459
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
