概要

        boost::thread 類的職責是啟動和管理線程對象。 大多數時候每個 boost::thread 實例代表一個獨立的線程: boost::thread 實例是不可拷貝的。

        boost::thread 實例是可轉移（movable）的 , 因此它們可以被存放到支持轉移語義（move-aware）的容器中, 由函數返回。 這樣使得線程對象的創建細節可以用函數包裝起來。

boost::thread make_thread();
void f()
{
boost::thread some_thread=make_thread();
some_thread.join();
}

         [注: 在支持右值引用的編譯器上， boost::thread 提供一個適當的轉移構造函數和轉移賦值操作, 以此來符合C++0x 中的可轉移拷貝和可轉移賦值的概念。   在這些編譯器的幫助下, boost::thread 能夠用於支持轉移語義的容器。

         對於其他的編譯器, 轉移語義由一個轉移模仿層來支持, 這樣容器需要顯式檢測模仿層。 詳細資料參考 <boost/thread/detail/move.hpp> ]

啟動線程

        通過傳遞一個擁有無參數構造函數的可調用對像來啟動一個線程。 這個對象會被拷貝，然後再線程執行的時期調用。 如果對像不支持拷貝If the object must not (or cannot) be copied, 可以通過 boost::ref 傳遞一個引用，在此種狀況下，該對像必須在線程執行期間存在。

struct callable
{
void operator()();
};
boost::thread copies_are_safe()
{
callable x;
return boost::thread(x);
} // x is destroyed, but the newly-created thread has a copy, so this is OK

boost::thread oops()
{
callable x;
return boost::thread(boost::ref(x));
} // x is destroyed, but the newly-created thread still has a reference
 // this leads to undefined behaviour

          如果你希望通過帶參數的函數或可調用對像來構造一個線程對象，可以通過將額外的參數傳遞給 boost::thread 構造函數的方法來實現:

void find_the_question(int the_answer);
boost::thread deep_thought_2(find_the_question,42);

          參數會被拷貝到線程內部: 如果需要使用參數引用, 請參照可調用對象的引用方法。

          對於額外參數的個數沒有限制。

線程函數中的異常

         如果傳遞給 boost::thread構造函數的線程函數或可調用對像在被調用時產生一個非boost::thread_interrupted 類型的異常， std::terminate()會被調用。

鄰連和分離

         當代表的線程執行體的 boost::thread 對像被銷毀的時候，線程執行體處於被分離的狀態（detached）。 線程執行體此時繼續執行，直到線程函數或可調用對像執行結束, 或者程序終止。 線程執行體也可以通過顯式調用boost::thread成員函數detach()分離（detach）， 在這種狀況下，boost::thread 對像結束了和線程執行體的關係，不在代表任何線程執行體（Not-a-Thread）。

         如果要等待一個線程結束, 使用 boost::thread 線程對象的成員函數join()或 timed_join()。 函數join() 會阻塞調用線程直到等待的線程對像執行結束。 如果等待的線程對像已經結束，或者等待的線程對像沒有關聯任何線程執行體（Not-a-Thread）, 函數 join() 會立即返回。 函數timed_join() 與join() 類似, 只是在等待指定的時間後也會返回。

 中斷

         一個執行著的線程可以通過調用對應boost::thread 對象的函數interrupt()來中斷。 當一個被中斷的線程在中斷打開時再次執行到某個特定的中斷點  interruption points (or if it is currently blocked whilst executing one) , 它會觸發一個boost::thread_interrupted 異常。 如果這個異常沒有被捕捉，會導致該線程終止。 如同其它異常一樣, 棧會被展開, 自動變量會被析構。

        如果一個線程不希望被中斷, 可以創建一個boost::this_thread::disable_interruption對像來達到這個目的。 該對像創建成功後，線程中斷關閉，直到該對像被銷毀:

void f()
{
// interruption enabled here
 {
boost::this_thread::disable_interruption di;
// interruption disabled
 {
boost::this_thread::disable_interruption di2;
// interruption still disabled
 } // di2 destroyed, interruption state restored
 // interruption still disabled
 } // di destroyed, interruption state restored
 // interruption now enabled
}

          boost::this_thread::disable_interruption對像關閉的線程中斷可以通過構建一個boost::this_thread::restore_interruption對像來臨時打開, 並在構造時傳遞對應的 boost::this_thread::disable_interruption object對像 。這樣將恢復線程中斷狀態到構建  boost::this_thread::disable_interruption object對像之前 , 當boost::this_thread::restore_interruption 對像銷毀的時候，線程中斷會再次處於關閉。

void g()
{
// interruption enabled here
 {
boost::this_thread::disable_interruption di;
// interruption disabled
 { 
boost::this_thread::restore_interruption ri(di);
// interruption now enabled
 } // ri destroyed, interruption disable again
 } // di destroyed, interruption state restored
 // interruption now enabled
}

        在任何時候，線程中斷狀態可以通過函數 boost::this_thread::interruption_enabled()來取得 。

 預定義的中斷點

        下列函數是中斷點（interruption points）, 會在被調用線程對像中斷開啟的情況下拋出boost::thread_interrupted 異常:

 線程標識(IDs)

         boost::thread::id 對象可用於標識線程。 每個執行期的線程都有一個唯一的標識，可通過成員函數get_id()獲得  , 或者在線程內部通過函數boost::this_thread::get_id()獲得 。 boost::thread::id  對像支持拷貝, 並提供完整的比較操作符，可以用於關聯式容器的鍵值 。 儘管沒有指定輸出格式,線程標識(Thread IDs) 還是可以以標準操作輸出到流。

        boost::thread::id 對象可能標識線程, 也可能沒有標識線程（Not-a-Thread）。 沒有標識線程的對象（Not-a-Thread）在比較時都是相同的, 但是和標識了線程的boost::thread::id對象都不一樣。 boost::thread::id的比較操作是一致的。

#include <boost/thread/thread.hpp>
class thread
{
public:
thread();
~thread();
template <class F>
explicit thread(F f);
template <class F,class A1,class A2,...>
thread(F f,A1 a1,A2 a2,...);
template <class F>
thread(detail::thread_move_t<F> f);
// move support
 thread(detail::thread_move_t<thread> x);
thread& operator=(detail::thread_move_t<thread> x);
operator detail::thread_move_t<thread>();
detail::thread_move_t<thread> move();
void swap(thread& x);
class id;
id get_id() const;
bool joinable() const;
void join();
bool timed_join(const system_time& wait_until);
template<typename TimeDuration>
bool timed_join(TimeDuration const& rel_time);
void detach();
static unsigned hardware_concurrency();
typedef platform-specific-type native_handle_type;
native_handle_type native_handle();
void interrupt();
bool interruption_requested() const;
// backwards compatibility
 bool operator==(const thread& other) const;
bool operator!=(const thread& other) const;
static void yield();
static void sleep(const system_time& xt);
};
void swap(thread& lhs,thread& rhs);

thread();

template<typename Callable>
thread(Callable func);

template <class F,class A1,class A2,...>
thread(F f,A1 a1,A2 a2,...);

~thread();

bool joinable() const;

void join();

bool timed_join(const system_time& wait_until);
template<typename TimeDuration>
bool timed_join(TimeDuration const& rel_time);

void detach();

thread::id get_id() const;

void interrupt();

unsigned hardware_concurrency();

typedef platform-specific-type native_handle_type;
native_handle_type native_handle();

bool operator==(const thread& other) const;

bool operator!=(const thread& other) const;

void sleep(system_time const& abs_time);

void yield();

void swap(thread& other);

#include <boost/thread/thread.hpp>
void swap(thread& lhs,thread& rhs);

#include <boost/thread/thread.hpp>
class thread::id
{
public:
id();
bool operator==(const id& y) const;
bool operator!=(const id& y) const;
bool operator<(const id& y) const;
bool operator>(const id& y) const;
bool operator<=(const id& y) const;
bool operator>=(const id& y) const;
template<class charT, class traits>
friend std::basic_ostream<charT, traits>& 
 operator<<(std::basic_ostream<charT, traits>& os, const id& x);
};

id();

bool operator==(const id& y) const;

bool operator!=(const id& y) const;

bool operator<(const id& y) const;

bool operator>(const id& y) const;

bool operator<=(const id& y) const;

bool operator>=(const id& y) const;

template<class charT, class traits>
friend std::basic_ostream<charT, traits>& 
operator<<(std::basic_ostream<charT, traits>& os, const id& x);

#include <boost/thread/thread.hpp>
namespace this_thread
{
thread::id get_id();
}

#include <boost/thread/thread.hpp>
namespace this_thread
{
void interruption_point();
}

#include <boost/thread/thread.hpp>
namespace this_thread
{
bool interruption_requested();
}

#include <boost/thread/thread.hpp>
namespace this_thread
{
bool interruption_enabled();
}

#include <boost/thread/thread.hpp>
namespace this_thread
{
template<typename TimeDuration>
void sleep(TimeDuration const& rel_time);
}

#include <boost/thread/thread.hpp>
namespace this_thread
{
void yield();
}

#include <boost/thread/thread.hpp>
namespace this_thread
{
class disable_interruption
{
public:
disable_interruption();
~disable_interruption();
};
}

disable_interruption();

~disable_interruption();

#include <boost/thread/thread.hpp>
namespace this_thread
{
class restore_interruption
{
public:
explicit restore_interruption(disable_interruption& disabler);
~restore_interruption();
};
}

explicit restore_interruption(disable_interruption& disabler);

~restore_interruption();

#include <boost/thread/thread.hpp>
template<typename Callable>
void at_thread_exit(Callable func);

#include <boost/thread/thread.hpp>
class thread_group:
private noncopyable
{
public:
thread_group();
~thread_group();
template<typename F>
thread* create_thread(F threadfunc);
void add_thread(thread* thrd);
void remove_thread(thread* thrd);
void join_all();
void interrupt_all();
int size() const;
};

thread_group();

~thread_group();

template<typename F>
thread* create_thread(F threadfunc);

void add_thread(thread* thrd);

void remove_thread(thread* thrd);

void join_all();

void interrupt_all();

int size();