Come ottenere un ID thread intero in c ++ 11

c ++ 11 ha la possibilità di ottenere l'id del thread corrente, ma non è castable al tipo intero:

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

uscita: 139918771783456

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

errore: cast non valido dal tipo "std :: thread :: id" al tipo "uint64_t" stesso per altri tipi: cast non valido dal tipo "std :: thread :: id" al tipo "uint32_t"

Non voglio davvero eseguire il casting del puntatore per ottenere l'id del thread intero. C'è un modo ragionevole (standard perché voglio che sia portatile) per farlo?

La soluzione portatile consiste nel passare i propri ID generati nel thread.

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

Il std::thread::idtipo deve essere utilizzato solo per i confronti, non per l'aritmetica (cioè come si dice sulla lattina: un identificatore ). Anche la sua rappresentazione testuale prodotta da nonoperator<< è specificata , quindi non puoi fare affidamento sul fatto che sia la rappresentazione di un numero.

Puoi anche usare una mappa di std::thread::idvalori per il tuo id e condividere questa mappa (con la corretta sincronizzazione) tra i thread, invece di passare direttamente l'id.

Hai solo bisogno di fare

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

per ottenere un file size_t.

Da cppreference :

La specializzazione del modello di std::hashper la std::thread::idclasse consente agli utenti di ottenere hash degli identificatori dei thread.

Un altro id (idea? ^^) potrebbe essere quello di utilizzare stringstream:

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

E usa try catch se non vuoi un'eccezione nel caso in cui le cose vadano storte ...

Un'idea potrebbe essere quella di utilizzare la memoria locale del thread per memorizzare una variabile - non importa di che tipo, purché sia ​​conforme alle regole della memorizzazione locale del thread - quindi utilizzare l'indirizzo di quella variabile come "ID thread". Ovviamente qualsiasi aritemetica non sarà significativa, ma sarà un tipo integrale.

Per i posteri: pthread_self()restituisce a pid_ted è posix. Questo è portabile per alcune definizioni di portabile.

gettid(), quasi certamente non portabile, ma restituisce un valore amichevole GDB.

Non so davvero quanto sia veloce, ma questa è la soluzione che sono riuscito a stimare:

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;

Ancora una volta sto iniziando a pensare che ottenere un puntatore alla struttura e lanciarlo su unsigned int o uint64_t sia la risposta ... 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 per prevenire problemi infernali :) Riscrivere è facile rispetto alla ricerca di questo tipo di bug. :)

thread::native_handle()restituisce thread::native_handle_type, che è un typedef per long unsigned int.

Se il thread è costruito in modo predefinito, native_handle () restituisce 0. Se c'è un thread del sistema operativo collegato ad esso, il valore restituito è diverso da zero (è pthread_t su POSIX).

In questo modo, dovrebbe funzionare:

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

Ricorda di includere la libreria sstream

Un motivo fondamentale per non utilizzare thread :: get_id () è che non è unico per un singolo programma / processo. Questo perché l'id può essere riutilizzato per un secondo thread, al termine del primo thread.

Questa sembra una caratteristica orribile, ma è ciò che è in c ++ 11.

dipende da cosa vuoi usare per thread_id; Puoi usare:

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

Questo genererà un ID univoco durante il processo; ma c'è una limitazione: se avvii più istanze dello stesso processo e ognuna di esse scrive i propri thread id in un file comune, l'unicità di thread_id non è garantita; infatti è molto probabile che avrai delle sovrapposizioni. In questo caso puoi fare qualcosa come:

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

ora ti vengono garantiti ID thread univoci in tutto il sistema.

Un'altra alternativa:

#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;
}

Il codice generato per questa funzione da g ++ in x86 a 64 bit è semplicemente:

_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

Cioè un singolo ramo senza alcuna sincronizzazione che verrà correttamente previsto tranne che per la prima volta che chiami la funzione. Dopodiché solo un singolo accesso alla memoria senza sincronizzazione.

Forse questa soluzione può essere utile a qualcuno. Chiamalo una prima volta im main(). Attenzione: namescresce indefinitamente.

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];
}