На основе класса scoped_thread, определенного в C++ Конкуренция в действии усиливается. Thread определяет класс обертки резьбы, который вместо вызова завершается, если поток присоединяется к разрушению, вызовите определенное действие, заданное в качестве параметра шаблона.

При этом класс scoped_thread определен в C++ Concurrency in Action ближе к классу strict_scoped_thread, который не допускает никаких изменений в обернутой нити. Thread предоставляет класс scoped_thread, который обеспечивает такой же непревзойденный интерфейс, как thread.

Скорпион Нити - это обертки вокруг нити, которые позволяют пользователю указывать, что делать во время разрушения. Одним из распространенных применений является присоединение к потоку во время разрушения, поэтому это поведение по умолчанию. Это единственное различие в отношении нити. В то время как поток вызывает std::terminate() на деструкторе, если поток является соединительным, strict_scoped_thread<> или scoped_thread<> присоединитесь к потоку, если присоединяемый.

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

boost::strict_scoped_thread<> t1((boost::thread(f)));
//t1.detach(); // compile fails
boost::scoped_thread<> t2((boost::thread(f)));
t2.detach();

//#include <boost/thread/scoped_thread.hpp>
struct detach;
struct join_if_joinable;
struct interrupt_and_join_if_joinable;

struct detach
{
  void operator()(thread& t)
  {
    t.detach();
  }
};

struct join_if_joinable
{
  void operator()(thread& t)
  {
    if (t.joinable())
    {
      t.join();
    }
  }
};

struct interrupt_and_join_if_joinable
{
  void operator()(thread& t)
  {
    t.interrupt();
    if (t.joinable())
    {
      t.join();
    }
  }
};

// #include <boost/thread/scoped_thread.hpp>
template <class CallableThread = join_if_joinable>
class strict_scoped_thread
{
  thread t_; // for exposition purposes only
public:
  strict_scoped_thread(strict_scoped_thread const&) = delete;
  strict_scoped_thread& operator=(strict_scoped_thread const&) = delete;
  explicit strict_scoped_thread(thread&& t) noexcept;
  template <typename F&&, typename ...Args>
  explicit strict_scoped_thread(F&&, Args&&...);
  ~strict_scoped_thread();
};

RAII thread обертка с добавлением конкретного эсминца, позволяющего освоить то, что можно сделать во время разрушения.

CallableThread: А Callable void(thread&).

По умолчанию это join_if_joinable.

Thread destructor завершает программу, если thread совместим. Эту обертку можно использовать для соединения нити перед ее разрушением.

Example

boost::strict_scoped_thread<> t((boost::thread(F)));

explicit strict_scoped_thread(thread&& t) noexcept;

template <typename F&&, typename ...Args>
explicit strict_scoped_thread(F&&, Args&&...);

~strict_scoped_thread();

#include <boost/thread/scoped_thread.hpp>
template <class CallableThread>
class scoped_thread
{
  thread t_; // for exposition purposes only
public:
    scoped_thread() noexcept;
    scoped_thread(const scoped_thread&) = delete;
    scoped_thread& operator=(const scoped_thread&) = delete;
    explicit scoped_thread(thread&& th) noexcept;
    template <typename F&&, typename ...Args>
    explicit scoped_thread(F&&, Args&&...);
    ~scoped_thread();
    // move support
    scoped_thread(scoped_thread && x) noexcept;
    scoped_thread& operator=(scoped_thread && x) noexcept;
    void swap(scoped_thread& x) noexcept;
    typedef thread::id id;
    id get_id() const noexcept;
    bool joinable() const noexcept;
    void join();
#ifdef BOOST_THREAD_USES_CHRONO
    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>& t);
#endif
    void detach();
    static unsigned hardware_concurrency() noexcept;
    static unsigned physical_concurrency() noexcept;
    typedef thread::native_handle_type native_handle_type;
    native_handle_type native_handle();
#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
    void interrupt();
    bool interruption_requested() const noexcept;
#endif
};
void swap(scoped_thread& lhs,scoped_thread& rhs) noexcept;

RAII thread обертка с добавлением конкретного эсминца, позволяющего освоить то, что можно сделать во время разрушения.

CallableThread: Скриншоты из игры Thread&. По умолчанию: join_if_joinable.

Thread destructor завершает программу, если резьба соединена. Эту обертку можно использовать для соединения нити перед ее разрушением.

Примечание: scoped_thread не является thread, поскольку thread не предназначен для получения из полиморфного типа.

В любом случае scoped_thread может использоваться в большинстве контекстов a thread может использоваться, поскольку он имеет тот же неустановленный интерфейс, за исключением конструкции.

Example

boost::scoped_thread<> t((boost::thread(F)));
t.interrupt();

scoped_thread() noexcept;

scoped_thread(scoped_thread&& other) noexcept;

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

scoped_thread(thread&& t);

template <typename F&&, typename ...Args>
explicit scoped_thread(F&&, Args&&...);

~scoped_thread();

bool joinable() const noexcept;

void join();

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

unsigned physical_concurrency() noexecpt;

typedef thread::native_handle_type native_handle_type;
native_handle_type native_handle();

void swap(scoped_thread& other) noexcept;