目錄

1.thread庫 ^

  Boost.Thread允許在可移植C ++程式碼中使用多個執行執行緒和共享資料。它提供了用於管理執行緒本身的類和函式，以及用於線上程之間同步資料或提供特定於各個執行緒的資料的單獨副本的其他類。

#include <boost/thread/thread.hpp>

namespace boost
{
  class thread;
  void swap(thread& lhs,thread& rhs) noexcept;

  namespace this_thread
  {
    thread::id get_id() noexcept
 
;
    template<typename TimeDuration>
    void yield() noexcept;
    template <class Clock, class Duration>
    void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
    template <class Rep, class Period>
    void sleep_for(const chrono::duration<Rep, Period>& rel_time);
    namespace
 
 no_interruption_point  // 擴充套件
    {
        template <class Clock, class Duration>
        void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
        template <class Rep, class Period>
        void sleep_for(const chrono::duration<Rep, Period>& rel_time);
    }
    template
 
<typename Callable>
    void at_thread_exit(Callable func); // 擴充套件

    void interruption_point(); // 擴充套件
    bool interruption_requested() noexcept; // 擴充套件
    bool interruption_enabled() noexcept; // 擴充套件
    class disable_interruption; // 擴充套件
    class restore_interruption; // 擴充套件

  #if defined BOOST_THREAD_USES_DATETIME
    template <TimeDuration>
    void sleep(TimeDuration const& rel_time);  // 擴充套件
    void sleep(system_time const& abs_time); // 擴充套件
  #endif
  }
  class thread_group; // 擴充套件

}

2.類thread ^

  ①類定義 ^

#include <boost/thread/thread.hpp>

class thread
{
public:
    class attributes; // EXTENSION

    thread() noexcept;
    ~thread();
    //刪除拷貝建構函式
    thread(const thread&) = delete;
    thread& operator=(const thread&) = delete;

    //移動建構函式和移動賦值運算子
    thread(thread&&) noexcept;
    thread& operator=(thread&&) noexcept;

    //利用函式構造一個執行緒，也可以用lambda表示式
    template <class Callable>
    explicit thread(Callable func);
    template <class Callable>
    thread(Callable &&func);

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

    template <class Callable>
    explicit thread(attributes& attrs,Callable func); // EXTENSION

    template <class Callable>
    thread(attributes& attrs, Callable &&func); // EXTENSION

    template <class F, class ...Args>
    explicit thread(attributes& attrs, F&& f, Args&&... args);

    //交換執行緒
    void swap(thread& x) noexcept;

    class id;
    //獲取執行緒id
    id get_id() const noexcept;
    //判斷是否為可執行的執行緒
    bool joinable() const noexcept;
    //執行緒加入等待佇列
    void join();
    //分離執行緒
    void detach();

    template <class Rep, class Period>
    bool try_join_for(const chrono::duration<Rep, Period>& rel_time); // EXTENSION
    template <class Clock, class Duration>
    bool try_join_until(const chrono::time_point<Clock, Duration>& t); // EXTENSION


    //當前系統可用的硬體執行緒數
    static unsigned hardware_concurrency() noexcept;
    //當前系統可用的物理核心數
    static unsigned physical_concurrency() noexcept;

    typedef platform-specific-type native_handle_type;
    //可以與特定於平臺的API一起使用來操作底層實現
    native_handle_type native_handle();

    //設定一箇中斷點
    void interrupt(); // 擴充套件
    //如果呼叫了interrupt()則返回true，否則返回false
    bool interruption_requested() const noexcept; // 擴充套件


#if defined BOOST_THREAD_USES_DATETIME
    bool timed_join(const system_time& wait_until); // 棄用
    template<typename TimeDuration>
    bool timed_join(TimeDuration const& rel_time); // 棄用
    static void sleep(const system_time& xt);// 棄用
#endif

#if defined BOOST_THREAD_PROVIDES_THREAD_EQ

    bool operator==(const thread& other) const; // 棄用
    bool operator!=(const thread& other) const; // 棄用

#endif
    static void yield() noexcept; // 棄用

};

void swap(thread& lhs,thread& rhs) noexcept;

  ②使用例子 ^

#include<iostream>
#include <boost/thread/thread.hpp>
using namespace boost;
using std::cout;
using std::endl;
int main()
{
    thread t([] {for (int i = 0; i != 10; ++i) { cout << "子執行緒：" << i << endl; }});
    t.interrupt();
    if (t.interruption_requested())
    {
        cout << "中斷" << endl;
    }
    if (t.joinable())
    {
        cout << "執行緒ID為：" << t.get_id() << endl;
        t.join();
    }
    cout << "當前系統可用的硬體執行緒數：" << t.hardware_concurrency() << endl;
    cout << "當前系統可用的物理核心數：" << t.physical_concurrency() << endl;    
}

3.名稱空間this_thread ^

  ①空間內定義 ^

namespace boost {
  namespace this_thread {
    //返回當前正在執行的執行緒的ID
    thread::id get_id() noexcept;

    //放棄當前執行緒的時間片的剩餘部分，以允許其他執行緒執行。
    template<typename TimeDuration>
    void yield() noexcept;

    //暫停當前執行緒直到指定的時間點abs_time
    template <class Clock, class Duration>
    void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
    //暫停執行緒rel_time時間
    template <class Rep, class Period>
    void sleep_for(const chrono::duration<Rep, Period>& rel_time);

    //將func放線上程的儲存中，當前執行緒退出時呼叫此副本(即使執行緒已被中斷)
    template<typename Callable>
    void at_thread_exit(Callable func);

    //請求中斷執行緒
    void interruption_point(); 
    //如果當前執行緒請求了中斷，則返回true，否則返回false
    bool interruption_requested() noexcept; 
    //如果已為當前執行緒啟用了中斷，則返回true，否則返回false
    bool interruption_enabled() noexcept; 

    //只有建構函式和祈構函式
    //建構函式：儲存 當前執行緒的當前狀態並禁用當前執行緒的中斷
    //祈構函式：將當前執行緒的當前狀態恢復為構造之前的狀態。
    class disable_interruption; 
    //建構函式：將當前執行緒的當前狀態恢復為構造之前的狀態
    //祈構函式：禁用當前執行緒的中斷
    class restore_interruption; 

  #if defined BOOST_THREAD_USES_DATETIME
    void sleep(TimeDuration const& rel_time); // 棄用
    void sleep(system_time const& abs_time);  // 棄用
  #endif
  }
}

  ②使用例子 ^

#include <boost/thread/thread.hpp>
using namespace boost::this_thread;
using std::cout;
using std::endl;
int main()
{
    at_thread_exit([] {for (int i = 0; i != 100; ++i)cout << "子執行緒：" << i << endl; });
    cout <<"執行緒ID："<<get_id() << endl;
    cout << "主執行緒" << endl;  
}

4.類thread_group ^

  thread_group提供以某種方式相關的執行緒集合。可以使用add_thread 和create_thread成員函式將新執行緒新增到組中。thread_group不可複製或移動。

  ①類定義 ^

#include  < boost / thread / thread 。hpp > 
class  thread_group 
{ 
public ：
    thread_group （const  thread_group ＆） =  delete ; 
    thread_group ＆ operator =（const  thread_group ＆） =  delete ; 
    //建立一個沒有執行緒的新執行緒組
    thread_group （）; 
    ~ thread_group （）; 

    //建立一個執行緒物件，並加入組中
    template < typename  F > 
    thread *  create_thread （F. threadfunc ）; 
    //獲取指向的物件的所有權，並將其新增到組中
    void  add_thread （thread *  thrd ）; 
    //移除執行緒物件
    void  remove_thread （thread *  thrd ）; 
    //如果組中有this_thread執行緒則返回true，否則返回false
    bool  is_this_thread_in （）; 
    //判斷一個執行緒是否在組中
    bool  is_thread_in （thread *  thrd ）; 
    //呼叫組中的每個物件
    void  join_all （）; 
    //請求中斷組中的每個物件？
    void  interrupt_all （）; 
    //組中的執行緒數
    int  size （） const ; 
};

  ②使用例子 ^

#include<iostream>
#include <boost/thread/thread.hpp>
using namespace boost;
using std::cout;
using std::endl;
int main()
{
    thread *t=new thread([] {cout << "不在組中的執行緒" << endl; });
    thread_group tg;
    auto t1 = tg.create_thread([] {cout << "第一個執行緒" << endl; });
    auto t2 = tg.create_thread([] {cout << "第二個執行緒" << endl; });
    //tg.add_thread(t);
    tg.join_all();
    tg.interrupt_all();
    if (tg.is_thread_in(t1))
        cout << "t1在組裡" << endl;
    if (tg.is_thread_in(t))
        cout << "t在組裡" << endl;
    if (tg.is_this_thread_in())
        cout << "this_thread執行緒在組裡" << endl;
    cout<<"組中的執行緒數："<<tg.size()<<endl;
    tg.remove_thread(t1);   //將執行緒t1移出組中
}