boost::thread线程创建方式总结

首先看看boost::thread的构造函数吧，boost::thread有两个构造函数：
（1）thread()：构造一个表示当前执行线程的线程对象；
（2）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;
}
---------------------------------------------------------------------


线程ID从boost::thread中分离出来，因此一个线程可以获得它自己的ID（使用boost::this_thread::get_id()),
并且这些ID可以用作关联容器的键值。


主线程，子线程 ， 线程， 资源的问题，线程同步问题


1.创建线程
2.使资源是线程安全的
保证同一时刻多个线程不会同时修改同一个共享资源，那么这个程序是线程安全的。
可以使用mutex类来控制线程的并发问题。

#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <iostream>
#include <string>


template<typename T>
class CQueue
{
public:
CQueue() {}
~CQueue() {}


void enqueue(const T& x)
{
boost::mutex::scoped_lock  lock(mutex_);
list_.push_back(x);
std::cout << "enqueue" << std::endl;
}


T dequeue()
{
boost::mutex::scoped_lock lock(mutex_);
if(list_.empty())
throw "empty!";
T tmp = list_.front();
list_.pop_front();
std::cout << "dequeue" << std::endl;
return tmp;
}
private:
std::list<T> list_;
boost::mutex mutex_;
};


CQueue<std::string> queue_string;


void send_something()
{
for(int i=0; i<4; ++i)
queue_string.enqueue("Cyrus");
}


void recv_something()
{
std::string s;
for(int i=0; i<4; ++i)
{
try
{
s = queue_string.dequeue();
}
catch(...){}
}
}


int main(int argc, char* argv[])
{
boost::thread thrd1(send_something);
boost::thread thrd2(recv_something);


thrd1.join();
thrd2.join();


return 0;
}


在某一时刻，只有一个线程可以锁定这个mutex对象。
这就阻止了同一时刻多个线程并发访问共享资源。