Как получить целочисленный идентификатор потока в c ++ 11

c ++ 11 имеет возможность получить текущий идентификатор потока, но он не может быть приведен к целочисленному типу:

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'

Я действительно не хочу выполнять приведение указателя, чтобы получить целочисленный идентификатор потока. Есть ли какой-нибудь разумный способ (стандартный, потому что я хочу, чтобы он был портативным) сделать это?

Переносимое решение - передать ваши собственные сгенерированные идентификаторы в поток.

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значений для своего собственного идентификатора и совместно использовать эту карту (с надлежащей синхронизацией) между потоками вместо передачи идентификатора напрямую.

Вам просто нужно сделать

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

чтобы получить size_t.

Из cppreference :

Специализация шаблона std::hashдля std::thread::idкласса позволяет пользователям получать хэши идентификаторов потоков.

Другой идентификатор (идея? ^^) - использовать строковые потоки:

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

И используйте try catch, если вы не хотите исключения в случае, если что-то пойдет не так ...

Одна из идей - использовать локальное хранилище потока для хранения переменной - неважно, какого типа, если он соответствует правилам локального хранилища потока - а затем использовать адрес этой переменной в качестве «идентификатора потока». Очевидно, что любая арифметика не будет иметь смысла, но это будет цельный тип.

Для потомков: pthread_self()возвращает a pid_tи is 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 - это ответ ... EDIT:

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. Если к нему подключен поток ОС, возвращаемое значение не равно нулю (это pthread_t в POSIX).

Таким образом должны работать:

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

Не забудьте включить библиотеку sstream

Основная причина не использовать thread :: get_id () заключается в том, что он не уникален для одной программы / процесса. Это потому, что идентификатор может быть повторно использован для второго потока после завершения первого потока.

Это кажется ужасной функцией, но это то, что есть в С ++ 11.

это зависит от того, для чего вы хотите использовать thread_id; вы можете использовать:

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

Это сгенерирует уникальный идентификатор внутри вашего процесса; но есть ограничение: если вы запускаете несколько экземпляров одного и того же процесса, и каждый из них записывает свои идентификаторы потока в общий файл, уникальность thread_id не гарантируется; на самом деле очень вероятно, что у вас будут совпадения. В этом случае вы можете сделать что-то вроде:

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

теперь вам гарантированы уникальные идентификаторы потоков во всей системе.

Другая альтернатива:

#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 ++ в 64-разрядной версии x86 выглядит так:

_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

Т.е. единственная ветвь без какой-либо синхронизации, которая будет правильно предсказана, за исключением первого вызова функции. После этого всего один доступ к памяти без синхронизации.

Может быть, это решение кому-то поможет. Назовите это впервые им 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];
}