如何在 C++11 中获取整数线程 ID

Question

c++11有可能获取当前线程id，但不能强制转换为整数类型：

cout<<std::this_thread::get_id()<<endl;

输出：139918771783456

cout<<(uint64_t)std::this_thread::get_id()<<endl;

错误：从类型“std::thread::id”到类型“uint64_t”的无效转换 其他类型相同： 从类型“std::thread::id”到类型“uint32_t”的无效转换

我真的不想通过指针转换来获取整数线程 id。有没有一些合理的方法（标准，因为我希望它是可移植的）来做到这一点？

Answer 1

你只需要这样做

std::hash<std::thread::id>{}(std::this_thread::get_id())

获取size_t。

来自cppreference：

std::hash 的模板特化 std::thread::id 类允许用户获取线程标识符的哈希值。

Answer 2

便携式解决方案是将您自己生成的 ID 传递到线程中。

int id = 0;
for(auto& work_item : all_work) {
    std::async(std::launch::async, [id,&work_item]{ work_item(id); });
    ++id;
}

std::thread::id 类型仅用于比较，而不用于算术（即，正如它在罐头上所说：一个标识符）。甚至它由operator<< 生成的文本表示也未指定，因此您不能依赖它作为数字的表示。

您还可以将std::thread::id 值映射到您自己的 id，并在线程之间共享此映射（通过适当的同步），而不是直接传递 id。

Answer 3

另一个 id（想法？^^）是使用字符串流：

std::stringstream ss;
ss << std::this_thread::get_id();
uint64_t id = std::stoull(ss.str());

如果您不想在出现异常的情况下出现异常，请使用 try catch...

Answer 4

一个想法是使用线程本地存储来存储一个变量——不管是什么类型，只要它符合线程本地存储的规则——然后使用该变量的地址作为你的“线程ID” ”。显然任何算术都没有意义，但它会是一个整数类型。

为了后代： pthread_self() 返回 pid_t 并且是 posix。对于便携的某些定义，这是便携的。

gettid()，几乎可以肯定是不可移植的，但它确实返回了对 GDB 友好的值。

Answer 5

不使用 thread::get_id() 的一个关键原因是它在单个程序/进程中不是唯一的。这是因为一旦第一个线程完成，该 id 就可以被第二个线程重用。

这似乎是一个可怕的功能，但它是 c++11 中的。

Answer 6

我真的不知道这有多快，但这是我设法猜测的解决方案：

const size_t N_MUTEXES=128;//UINT_MAX,not 128  for answer to my original question
hash<std::thread::id> h;
cout<<h(std::this_thread::get_id())%N_MUTEXES<<endl;

我再次开始认为获得一个指向结构的指针并将其转换为 unsigned int 或 uint64_t 是答案...... 编辑：

uint64_t get_thread_id()
{
    static_assert(sizeof(std::thread::id)==sizeof(uint64_t),"this function only works if size of thead::id is equal to the size of uint_64");
    auto id=std::this_thread::get_id();
    uint64_t* ptr=(uint64_t*) &id;
    return (*ptr);
}
int main()
{
    cout<<std::this_thread::get_id()<<"  "<<get_thread_id()<<endl;
}

static_assert 来防止地狱般的问题 :) 与寻找这种错误相比，重写很容易。 :)

Answer 7

这样，应该可以了：

std::stringstream ss;
ss << std::this_thread::get_id();
int id = std::stoi(ss.str());

记得包含库流

Answer 8

thread::native_handle() 返回thread::native_handle_type，这是long unsigned int 的类型定义。

如果线程是默认构造的，native_handle() 返回 0。 如果有一个 OS 线程附加到它，则返回值非零（在 POSIX 上为 pthread_t）。

Answer 9

另一种选择：

#include <atomic>

static std::atomic<unsigned long long> thread_counter;

unsigned long long thread_id() {
    thread_local unsigned long long tid = ++thread_counter;
    return tid;
}

g++ 在 x86 64 位中为这个函数生成的代码就是：

_Z9thread_idv:
        cmp     BYTE PTR fs:_ZGVZ9thread_idvE3tid@tpoff, 0
        je      .L2
        mov     rax, QWORD PTR fs:_ZZ9thread_idvE3tid@tpoff
        ret
.L2:
        mov     eax, 1
        lock xadd       QWORD PTR _ZL14thread_counter[rip], rax
        mov     BYTE PTR fs:_ZGVZ9thread_idvE3tid@tpoff, 1
        mov     QWORD PTR fs:_ZZ9thread_idvE3tid@tpoff, rax
        ret
_ZGVZ9thread_idvE3tid:
        .zero   8
_ZZ9thread_idvE3tid:
        .zero   8

即没有任何同步的单个分支，除了您第一次调用该函数外，它将被正确预测。之后只是一个没有同步的内存访问。

Answer 10

这取决于你想用thread_id做什么； 你可以使用：

std::stringstream ss;
ss << std::this_thread::get_id();
uint64_t id = std::stoull(ss.str());

这将在您的进程中生成一个唯一的 ID；但是有一个限制：如果您启动同一进程的多个实例，并且每个实例都将其线程 ID 写入一个公共文件，则无法保证 thread_id 的唯一性；事实上，你很可能会有重叠。 在这种情况下，您可以执行以下操作：

#include <sys/time.h>
timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
uint64_t id = (ts.tv_sec % 1000000000) * 1000000000 + ts.tv_nsec;

现在保证您在系统范围内拥有唯一的线程 ID。

Answer 11

也许这个解决方案对某人有帮助。第一次打电话给我main()。警告：names 无限增长。

std::string currentThreadName(){
    static std::unordered_map<std::thread::id,std::string> names;
    static std::mutex mtx;

    std::unique_lock<std::mutex> lock(mtx);

    auto id = std::this_thread::get_id();

    if(names.empty()){
        names[id] = "Thread-main";
    } else if(names.find(id) == names.end()){
        std::stringstream stream;
        stream << "Thread-" << names.size();
        names[id] = stream.str();
    }

    return names[id];
}