C++11 'native_handle' is not a member of 'std::this_thread' - c++

Question

In the following code snippet,
void foo() {
std::this_thread::native_handle().... //error here
}
int main() {
std::thread t1(foo);
t1.join();
return 0;
}
How do you get the native_handle from std::this_thread from within the function foo?

Answer 1

There is no way for a thread to autonomously gain access to its own std::thread. This is on purpose since std::thread is a move-only type.
I believe what you're requesting is a native_handle() member of std::thread::id, and that is an interesting suggestion. As far as I know it is not currently possible. It would be used like:
void foo()
{
auto native_me = std::this_thread::get_id().native_handle();
// ...
}
It wouldn't be guaranteed to work, or even exist. However I imagine most POSIX platforms could support it.
One way to try to change the C++ standard is to submit issues. Here are directions on how to do so.

Answer 2

C++11 does not provide a mechanism for getting the current threads native_handle. You must use platform specific calls, i.e. GetCurrentThread() on Windows:
void foo()
{
auto native_me = ::GetCurrentThread();
}

Answer 3

As Howard pointed, there is no support for this in ISO C++ yet.
But thread::id has an overloaded operator<< to print itself to an ostream.
#include <iostream>
#include <thread>
int main()
{
std::cout << "Current thread ID: " << std::this_thread::get_id() << std::endl;
}
Without knowing the semantics of the actual value (which is highly platform-dependent), printing it or using it as a key in a map is the most you should be doing anyway.

Answer 4

Currently(C++17) you can't get native_handle from std::this_thread
The most possible interface might be std::this_thread::native_handle(). But not std::this_thread::get_id().native_handle(); by #Howard
Since Win/Linux/MacOS implement thread and thread::id differently: (below is informal pseudo code)
On Linux native_handle is stored at thread._M_id(of type id)._M_thread.
On Windows native_handle is stored at thread._Thr(of type _Thrd_t, not of type id)._Hnd.
On MacOS native_handle is stored at thread.__t_.
As you can see only in Linux source there is native_hanlde object implemented in thread::id structure. Thus on Win/MacOS you can't get the native_handle from an id object.
Finally, if your code runs only in Linux, there is a dirty trick to get native_handle from this_thread which I will never recommend:
auto thread_id = std::this_thread::get_id();
auto native_handle = *reinterpret_cast<std::thread::native_handle_type*>(&thread_id);

Answer 5

In fact, there is one funny way to circumvent the problem and access it via std::thread , which may work in some cases.
The original example was posted on this blog. I rewritten it.
You can save the code below to test.cpp and compile & run it
:
// 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;
}