c++ - C++11 'native_handle' 不是 'std::this_thread' 的成员

Question

在以下代码片段中，

void foo() {
  std::this_thread::native_handle().... //error here
}

int main() {
  std::thread t1(foo);

  t1.join();
  return 0;
}

你如何native_handle从std::this_thread函数中获取 from foo？

Answer 1

线程没有办法自主地访问它自己的std::thread. 这是故意的，因为std::thread它是只移动类型。

我相信您要求的是 的native_handle()成员std::thread::id，这是一个有趣的建议。据我所知，目前是不可能的。它会像这样使用：

void foo()
{
    auto native_me = std::this_thread::get_id().native_handle();
    // ...
}

它不能保证工作，甚至存在。但是我想大多数 POSIX 平台都可以支持它。

尝试更改 C++ 标准的一种方法是提交问题。 以下是有关如何执行此操作的说明。

Answer 2

C++11 没有提供获取当前线程 native_handle 的机制。您必须使用特定于平台的调用，即 Windows 上的 GetCurrentThread()：

void foo()
{
    auto native_me = ::GetCurrentThread();
}

Answer 3

正如霍华德所指出的，ISO C++ 中还没有对此的支持。

但是thread::id有一个重载operator<<将自己打印到一个ostream.

#include <iostream>
#include <thread>

int main()
{
    std::cout << "Current thread ID: " << std::this_thread::get_id() << std::endl;
}

在不知道实际值的语义（高度依赖于平台）的情况下，打印它或将其用作映射中的键是无论如何你应该做的最多的事情。

Answer 4

目前（C++17）你不能native_handle从std::this_thread

最可能的界面可能是std::this_thread::native_handle(). 但不是std::this_thread::get_id().native_handle();@Howard

由于 Win/Linux/MacOS 的实现thread方式thread::id不同：（下面是非正式的伪代码）

• 在 Linuxnative_handle上存储在线程中。_M_id（类型 id） ._M_thread。
• 在 Windowsnative_handle上存储在 thread._Thr（类型为 _Thrd_t，而不是类型 id）._Hnd。
• 在 MacOSnative_handle上存储在 thread.__t_。

正如您只能在 Linux 源代码中看到的那样，在结构中native_hanlde实现了对象。thread::id因此，在 Win/MacOS 上，您无法native_handle从id对象中获取。

最后，如果您的代码仅在 Linux 中运行，那么我绝不会建议您native_handle从中获得一个肮脏的技巧：this_thread

auto thread_id = std::this_thread::get_id();
auto native_handle = *reinterpret_cast<std::thread::native_handle_type*>(&thread_id);

Answer 5

事实上，有一种有趣的方法可以绕过问题并通过 std::thread 访问它，这在某些情况下可能有效。原始示例发布在此博客上。我重写了它。您可以将下面的代码保存到 test.cpp 并编译并运行它：

// g++ ./test.cpp  -lpthread && ./a.out
// 
#include <thread>
#include <vector>
#include <iostream>
#include <mutex>
#include <sched.h>
#include <pthread.h>
int main(int argc, const char** argv) {
  constexpr unsigned num_threads = 4;
  // A mutex ensures orderly access to std::cout from multiple threads.
  std::mutex iomutex;
  std::vector<std::thread> threads(num_threads);
  for (unsigned i = 0; i < num_threads; ++i) {
    threads[i] = std::thread([&iomutex, i,&threads] {
      // Create a cpu_set_t object representing a set of CPUs. Clear it and mark
      // only CPU i as set.
      cpu_set_t cpuset;
      CPU_ZERO(&cpuset);
      CPU_SET(i, &cpuset);
      int rc = pthread_setaffinity_np(threads[i].native_handle(),
                                      sizeof(cpu_set_t), &cpuset);
      if (rc != 0) {
        std::cerr << "Error calling pthread_setaffinity_np: " << rc << "\n";
      }
      std::this_thread::sleep_for(std::chrono::milliseconds(20));
      while (1) {
        {
          // Use a lexical scope and lock_guard to safely lock the mutex only
          // for the duration of std::cout usage.
          std::lock_guard<std::mutex> iolock(iomutex);
          std::cout << "Thread #" << i << ": on CPU " << sched_getcpu() << "\n";
        }

        // Simulate important work done by the tread by sleeping for a bit...
        std::this_thread::sleep_for(std::chrono::milliseconds(900));
      }
    });


  }

  for (auto& t : threads) {
    t.join();
  }
  return 0;
}