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

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。有某种合理的方法（因为我希望它是便携式的，所以是标准的）吗？

可移植的解决方案是将您自己生成的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。

你只需要做

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

得到一个size_t。

来自cppreference：

的模板专门std::hash为std::thread::id类允许用户获得线程的标识符的哈希值。

另一个id（idea？^^）将使用stringstreams：

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

如果在发生错误的情况下不希望出现异常，请使用try catch。

一种想法是使用线程本地存储来存储变量-不管什么类型，只要它符合线程本地存储的规则即可-然后使用该变量的地址作为您的“线程ID”。显然，任何算术运算都是没有意义的，但它将是一个不可或缺的类型。

对于后代： pthread_self()返回apid_t和posix。对于可移植性的某些定义，这是可移植的。

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

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

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可以防止地狱般的问题:)与查找此类错误相比，重写很容易。:)

thread::native_handle()返回thread::native_handle_type，这是typedef long unsigned int。

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

这样，应该工作：

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

切记要包含库sstream

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

这似乎是一个可怕的功能，但在c ++ 11中却是什么。

这取决于您要使用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。

另一种选择：

#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

即一个分支，除了您第一次调用该函数外，没有任何可以正确预测的同步。之后，仅一次内存访问就没有同步。

也许此解决方案对某人有帮助。第一次称呼它为im 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];
}