コンテンツにスキップ

最終更新：2026-10-12

C++ std::thread の内部実装

std::thread を深く解き明かす

lambdaを書いてthreadに渡すとき、スレッドの生成とtaskの呼び出しはいつトリガーされるのでしょうか？

auto t = std::thread([this] {
  // do something
});

このスレッドには1つのlambdaが渡されています。そこで本節で解決する問題は、このlambdaはいつトリガーされるのか？というものです。構築されるときでしょうか？それともどこかで呼び出されるときでしょうか？

さあ、一緒にソースコードの世界へ入っていきましょう。

1._M_make_routine

本節で分析するコードはそれぞれ次のとおりです：

1) ヘッダファイル

https://github.com/gcc-mirror/gcc/blob/releases/gcc-4.9/libstdc%2B%2B-v3/include/std/thread

  1. 実装ファイル

https://github.com/gcc-mirror/gcc/blob/releases/gcc-4.9/libstdc%2B%2B-v3/src/c%2B%2B11/thread.cc

  1. posixヘッダファイル

https://github.com/gcc-mirror/gcc/blob/releases/gcc-4.9/libgcc/gthr-posix.h

上記のコードは、次のコンストラクタを呼び出します：

template<typename _Callable, typename... _Args>
explicit 
thread(_Callable&& __f, _Args&&... __args)
{
  _M_start_thread(_M_make_routine(std::__bind_simple(
          std::forward<_Callable>(__f),
          std::forward<_Args>(__args)...)));
}

__fが私たちが渡したlambdaです。ここではbindによってlambdaと引数がバインドされ、その後_M_make_routineに渡されることで、_Implが構築されます。

template<typename _Callable>
      shared_ptr<_Impl<_Callable>>
      _M_make_routine(_Callable&& __f)
      {
    // Create and allocate full data structure, not base.
    return std::make_shared<_Impl<_Callable>>(std::forward<_Callable>(__f));
      }

そして_Implの中に格納されているのが、先ほどbindが返した結果である_M_funcです。

template<typename _Callable>
      struct _Impl : public _Impl_base
      {
    _Callable       _M_func;

    _Impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f))
    { }

    void
    _M_run() { _M_func(); }
      };

その後、_M_make_routineで生成されたshared_ptr<_Impl<_Callable>>が_M_start_threadに渡されます。

2._M_start_thread

_M_start_threadは__gthread_createを呼び出します。ここではexecute_native_thread_routineが渡されます。

void
  thread::_M_start_thread(__shared_base_type __b)
  {
    if (!__gthread_active_p())
#if __EXCEPTIONS
      throw system_error(make_error_code(errc::operation_not_permitted),
             "Enable multithreading to use std::thread");
#else
      __throw_system_error(int(errc::operation_not_permitted));
#endif

    __b->_M_this_ptr = __b;
    int __e = __gthread_create(&_M_id._M_thread,
                   &execute_native_thread_routine, __b.get());
    if (__e)
    {
      __b->_M_this_ptr.reset();
      __throw_system_error(__e);
    }
  }

キーポイント1：execute_native_thread_routine

以下のコードから、いくつかの情報が得られます：

1つ目：なぜextern "C"にするのか

2つ目：_M_run()が呼び出されている

  extern "C"
  {
    static void*
    execute_native_thread_routine(void* __p)
    {
      thread::_Impl_base* __t = static_cast<thread::_Impl_base*>(__p);
      thread::__shared_base_type __local;
      __local.swap(__t->_M_this_ptr);

      __try
    {
      __t->_M_run();
    }
      __catch(const __cxxabiv1::__forced_unwind&)
    {
      __throw_exception_again;
    }
      __catch(...)
    {
      std::terminate();
    }

      return 0;
    }
  } // extern "C"

キーポイント2：__gthread_create

pthread_createを呼び出しています

static inline int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
          void *__args)
{
  return __gthrw_(pthread_create) (__threadid, NULL, __func, __args);
}

さて、上の流れを整理してみましょう。std::threadを構築するとき、私たちは自分のcallback(lambda)を渡してビジネスロジックを実行させます。std::threadのコンストラクタはpthread_createの呼び出しを発行し、同時にexecute_native_thread_routineをC言語風にpthread_createへ渡します。pthread_createの実行時にexecute_native_thread_routineが実行され、その中の_M_run()が実行されます。これが、私たちのlambda関数の呼び出しに対応しています。

本節では、スレッドの呼び出しについて一歩踏み込んだ理解が得られました。学ぶことはできましたか？ぜひシェアをお願いします。

関連トピック

コメント