Новый поток запускается путем передачи объекта вызывающего типа, который может быть вызван без параметров конструктору. Затем объект копируется во внутреннее хранилище и вызывается на вновь созданную нить исполнения. Если объект не должен (или не может) быть скопирован, то<boost::ref>можно использовать для передачи ссылки на объект функции. В этом случае пользовательBoost.Threadдолжен убедиться, что объект, о котором идет речь, переживет вновь созданную нить исполнения.

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>с функцией или вызывающим объектом, который требует предоставления аргументов, это можно сделать, передав дополнительные аргументы конструктору<boost::thread>:

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

Аргументыскопированыво внутреннюю структуру потока: если требуется ссылка, используйте<boost::ref>, как и для ссылок на вызывающие функции.

Существует неопределенный лимит на количество дополнительных аргументов, которые могут быть приняты.

Запущенный таким образом поток создается с помощью реализации определенных атрибутов потока как размер стека, планирование, приоритет, ... или любые специфические атрибуты платформы. Непонятно, как обеспечить портативный интерфейс, позволяющий пользователю задавать платформе определенные атрибуты. Повышаю. Нить остается на средней дороге через нить класса:: атрибуты, которые позволяют установить, по крайней мере, портативным способом размер стека следующим образом:

boost::thread::attributes attrs;
attrs.set_stack_size(4096*10);
boost::thread deep_thought_2(attrs, find_the_question, 42);

Даже для этого простого атрибута могут быть проблемы с переносом, поскольку для некоторых платформ размер стека должен иметь минимальный размер и / или быть кратным заданному размеру страницы. Библиотека адаптирует запрашиваемый размер к ограничениям платформы, чтобы пользователю не нужно было заботиться о нем.

Это единственный атрибут, который предоставляется портативным способом. Для того чтобы установить любой другой атрибут потока во время строительства, пользователю необходимо использовать непортативный код.

На платформах PThread пользователю нужно будет получить ручку атрибутов потока и использовать ее для любого атрибута.

Далее следует, как пользователь может установить размер стека и политику планирования на платформах PThread.

boost::thread::attributes attrs;
// set portable attributes
// ...
attr.set_stack_size(4096*10);
#if defined(BOOST_THREAD_PLATFORM_WIN32)
    // ... window version
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
    // ... pthread version
    pthread_attr_setschedpolicy(attr.native_handle(), SCHED_RR);
#else
#error "Boost threads unavailable on this platform"
#endif
boost::thread th(attrs, find_the_question, 42);

На платформах Windows это не так просто, так как нет типа, который компилирует атрибуты потоков. Существует связь с созданием потока в Windows, который эмулируется через поток::Attributes class. Это атрибуты LPSECURITY_ATTRIBUTES lpThreadAttributes. Повышаю. Thread предоставляет непортативную функцию set_security, чтобы пользователь мог предоставить ее перед созданием потока следующим образом:

#if defined(BOOST_THREAD_PLATFORM_WIN32)
  boost::thread::attributes attrs;
  // set portable attributes
  attr.set_stack_size(4096*10);
  // set non portable attribute
  LPSECURITY_ATTRIBUTES sec;
  // init sec 
  attr.set_security(sec);
  boost::thread th(attrs, find_the_question, 42);
  // Set other thread attributes using the native_handle_type.
  //...
#else
#error "Platform not supported"
#endif

Если функция или вызывающий объект перешли к<boost::thread>Конструктор распространяет исключение, когда на него ссылаются, которое не относится к типу<boost::thread_interrupted>,<std::terminate()>называется.

Поток может быть отделен путем явного вызова.<detach()>Функция члена на<boost::thread>объекте. В этом случае<boost::thread>объект перестает представлять теперь отдельную нить, а вместо этого представляет.Не-нить.

int main()
{
  boost::thread t(my_func);
  t.detach();
}

Для того, чтобы дождаться окончания нити исполнения, необходимо использовать<join()>, __join_for или __join_until<timed_join()>функции члена объекта<boost::thread>.<join()>будет блокировать вызывающую нить, пока нить, представленная<boost::thread>Объект завершен.

int main()
{
  boost::thread t(my_func);
  t.join();
}

Если нить исполнения, представленная<boost::thread>объектом, уже завершена, или<boost::thread>объект представляетНе-нить, то<join()>возвращается немедленно.

int main()
{
  boost::thread t;
  t.join(); // do nothing
}

Присоединение на основе времени аналогично, за исключением того, что вызов __join_for или __join_until также вернется, если ожидаемый поток не завершится, когда указанное время истекло или достигло соответственно.

int main()
{
  boost::thread t;
  if ( t.join_for(boost::chrono::milliseconds(500)) )
    // do something else
  t.join(); // join anyway
}

Когда объект<boost::thread>, представляющий нить исполнения, разрушается, нить становитсяотсоединенной. Как только нить отделена, она будет продолжать выполняться до тех пор, пока не будет завершен вызов функции или вызывающего объекта, поставляемого на строительство, или программа не будет завершена. Нить также может быть отделена путем явного вызова.<detach()>функция члена на<boost::thread>объекте. В этом случае<boost::thread>объект перестает представлять теперь отдельную нить, а вместо этого представляетНе-нить.

Когда объект<boost::thread>, представляющий нить выполнения, разрушается, программа прекращает работу, если нить __joinable__.

int main()
{
  boost::thread t(my_func);
} // calls std::terminate()

Вы можете использовать thread_joiner, чтобы убедиться, что поток был соединен с разрушителем потока.

int main()
{
  boost::thread t(my_func);
  boost::thread_joiner g(t);
  // do something else
} // here the thread_joiner destructor will join the thread before it is destroyed.

Бегущая нить может бытьпрерванапутем вызова.<interrupt()>функция члена соответствующего<boost::thread>объекта. Когда прерванный поток далее выполняет одну из указанныхточек прерывания(или если он в настоящее времязаблокированпри выполнении одного) с включенным прерыванием, то в прерванный поток будет брошено исключение<boost::thread_interrupted>. Если это исключение не улавливается внутри основной функции прерываемого потока, процесс раскручивания стека (как и любое другое исключение) вызывает выполнение деструкторов с автоматической продолжительностью хранения. В отличие от других исключений, когда<boost::thread_interrupted>распространяется из основной функции резьбы, это не вызывает призыва к<std::terminate>; эффект таков, как будто основная функция резьбы вернулась нормально.

Если нить желает избежать прерывания, она может создать экземпляр<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>. Это восстановит состояние прерывания до того, как оно было.<boost::this_thread::disable_interruption>объект был построен, а затем снова отключить прерывание, когда<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()>.

Predefined Interruption Points

Следующими функциями являютсяточки прерывания, которые будут бросать<boost::thread_interrupted>, если прерывание включено для текущего потока, и прерывание запрашивается для текущего потока:

Объекты класса<boost::thread::id>могут использоваться для идентификации потоков. Каждый исполняемый поток исполнения имеет уникальный идентификатор, получаемый из соответствующего<boost::thread>путем вызова функции<get_id()>члена или вызова<boost::this_thread::get_id()>из потока. Объекты класса<boost::thread::id>могут копироваться и использоваться в качестве ключей в ассоциативных контейнерах: предоставляется полный спектр операторов сравнения. Идентификаторы потока также могут быть записаны в выходной поток с помощью оператора вставки потока, хотя выходной формат не указан.

Каждый экземпляр<boost::thread::id>либо относится к некоторой нити, либоНе-нить. Случаи, относящиеся кНе-нитьсравниваются равными друг другу, но не равными любым экземплярам, которые относятся к фактической нити исполнения. Операторы сравнения на<boost::thread::id>дают общий заказ на каждый неравный идентификатор потока.

<boost::thread>класс имеет членов<native_handle_type>и<native_handle>, обеспечивающих доступ к базовой нативной рукоятке.

Эта нативная ручка может быть использована для изменения, например, расписания.

В общем, небезопасно использовать эту ручку с операциями, которые могут конфликтовать с теми, которые предоставляет Boost. Нить. Примером плохого использования может быть отсоединение потока непосредственно, поскольку оно не изменит внутренние части экземпляра<boost::thread>, поэтому, например, присоединяемая функция будет продолжать возвращать истинность, в то время как нативная резьба больше не присоединяется.

thread t(fct);
thread::native_handle_type hnd=t.native_handle();
pthread_detach(hnd);
assert(t.joinable());

Любой поток выполнения, созданный с помощью нативного интерфейса, называется нативным потоком в этой документации.

Первый пример нативной нити исполнения является основной нитью.

Пользователь может получить доступ к некоторым функциям синхронизации, связанным с потоком нативного тока, используя функции<boost::this_thread><yield>,<sleep>,<sleep_for>,<sleep_until>.

int main() {
  // ... 
  boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
  // ... 
}

Конечно, все средства синхронизации предоставлены Boost. Нить также доступна на родных нитях.

Функции, связанные с прерыванием<boost::this_thread>, ведут себя в деградированном режиме при вызове из потока, созданного с использованием нативного интерфейса, то есть<boost::this_thread::interruption_enabled()>возвращает ложное. Как следствие, использование<boost::this_thread::disable_interruption>и<boost::this_thread::restore_interruption>ничего не сделает, и призывы к<boost::this_thread::interruption_point()>будут просто проигнорированы.

Поскольку единственный способ прервать нить - через экземпляр<boost::thread>,<interruption_request()>вернется ложным для нативных нитей.

pthread_exit POSIX limitation

<pthread_exit>в glibc/NPTL вызывает «вынужденное раскручивание», что почти похоже на исключение C++, но не совсем. На Mac OS X, например,<pthread_exit>разворачивается без вызова деструкторов C++.

Такое поведение несовместимо с нынешним ростом. Конструкция нити, поэтому использование этой функции в потоке POSIX приводит к неопределенному поведению любого Boost. Функция нити.

thread() noexcept;

thread(thread&& other) noexcept;

thread& operator=(thread&& other) noexcept;

template<typename Callable>
thread(Callable func);

template<typename Callable>
thread(attributes& attrs, Callable func);

template<typename Callable>
thread(Callable &&func);

template<typename Callable>
thread(attributes& attrs, Callable func);

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

~thread();

bool joinable() const noexcept;

void join();

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

	Warning
	Снят с 3.00. Используйте вместо этого<try_join_for>,<try_join_until>.

template <class Rep, class Period>
bool try_join_for(const chrono::duration<Rep, Period>& rel_time);

template <class Clock, class Duration>
bool try_join_until(const chrono::time_point<Clock, Duration>& abs_time);

void detach();

thread::id get_id() const noexcept;

void interrupt();

unsigned hardware_concurrency() noexcept;

unsigned physical_concurrency() noexcept;

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

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

	Warning
	Снят с 4.0.0. Используйте<a.get_id>() ==b.<get_id>()вместо этого.

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

	Warning
	Снят с 4.0.0. Используйте<a.get_id>()!=b.<get_id>()вместо этого.

void sleep(system_time const& abs_time);

	Warning
	Снят с 3.0.0. Используйте<this_thread::sleep_for>()или<this_thread::sleep_until>().

void yield();

	Warning
	Снят с 3.0.0. Используйте<this_thread::yield>().

void swap(thread& other) noexcept;

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

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

id() noexcept;

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

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

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

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

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

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

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

class thread::attributes {
public:
    attributes() noexcept;
    ~ attributes()=default;
    // stack
    void set_stack_size(std::size_t size) noexcept;
    std::size_t get_stack_size() const noexcept;
#if defined BOOST_THREAD_DEFINES_THREAD_ATTRIBUTES_NATIVE_HANDLE
    typedef platform-specific-type native_handle_type;
    native_handle_type* native_handle() noexcept;
    const native_handle_type* native_handle() const noexcept;
#endif
};

thread_attributes() noexcept;

void set_stack_size(std::size_t size) noexcept;

std::size_t get_stack_size() const noexcept;

typedef platform-specific-type native_handle_type;
    typedef platform-specific-type native_handle_type;
    native_handle_type* native_handle() noexcept;
    const native_handle_type* native_handle() const noexcept;

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

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

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

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

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

	Warning
	Снят с 3.0.0. Вместо этого используйте<sleep_for>[]и<sleep_until>.

#include <boost/thread/thread.hpp>
namespace this_thread
{
  template <class Clock, class Duration>
  void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
  namespace no_interruption_point
  {
    template <class Clock, class Duration>
    void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
  }
}

#include <boost/thread/thread.hpp>
namespace this_thread
{
  template <class Rep, class Period>
  void sleep_for(const chrono::duration<Rep, Period>& rel_time);
  namespace no_interruption_point
  {
    template <class Rep, class Period>
    void sleep_for(const chrono::duration<Rep, Period>& rel_time);
  }
}

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

#include <boost/thread/thread.hpp>
namespace this_thread
{
    class disable_interruption
    {
    public:
        disable_interruption(const disable_interruption&) = delete;
        disable_interruption& operator=(const disable_interruption&) = delete;
        disable_interruption() noexcept;
        ~disable_interruption() noexcept;
    };
}

<boost::this_thread::disable_interruption>отключает прерывание для текущей нити на строительстве и восстанавливает состояние предыдущего прерывания на разрушении. Случаи<disable_interruption>нельзя копировать или перемещать.

disable_interruption() noexcept;

~disable_interruption() noexcept;

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

При строительстве экземпляра<boost::this_thread::restore_interruption>состояние прерывания для текущей резьбы восстанавливается до состояния прерывания, сохраненного конструктором поставляемого экземпляра<boost::this_thread::disable_interruption>. Когда экземпляр уничтожен, прерывание снова отключено. Случаи<restore_interruption>не могут быть скопированы или перенесены.

explicit restore_interruption(disable_interruption& disabler) noexcept;

~restore_interruption() noexcept;

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

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();

bool is_this_thread_in();

bool is_thread_in(thread* thrd);

void interrupt_all();

int size();