So erhalten Sie eine ganzzahlige Thread-ID in C ++ 11

c ++ 11 hat die Möglichkeit, die aktuelle Thread-ID abzurufen, kann jedoch nicht in einen ganzzahligen Typ umgewandelt werden:

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

Ausgabe: 139918771783456

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

Fehler: Ungültige Umwandlung vom Typ 'std :: thread :: id' in Typ 'uint64_t'. Gleiches gilt für andere Typen. Ungültige Umwandlung vom Typ 'std :: thread :: id' in Typ 'uint32_t'.

Ich möchte wirklich kein Zeiger-Casting durchführen, um die Ganzzahl-Thread-ID zu erhalten. Gibt es eine vernünftige Möglichkeit (Standard, weil ich möchte, dass es portabel ist), dies zu tun?

Die tragbare Lösung besteht darin, Ihre eigenen generierten IDs an den Thread zu übergeben.

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

Der std::thread::idTyp darf nur für Vergleiche verwendet werden, nicht für Arithmetik (dh wie auf der Dose steht: ein Bezeichner ). Sogar die von dargestellte Textdarstellung operator<<ist nicht spezifiziert , sodass Sie sich nicht darauf verlassen können, dass es sich um die Darstellung einer Zahl handelt.

Sie können auch eine Zuordnung von std::thread::idWerten zu Ihrer eigenen ID verwenden und diese Zuordnung (mit ordnungsgemäßer Synchronisierung) für die Threads freigeben, anstatt die ID direkt zu übergeben.

Sie müssen nur tun

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

um eine zu bekommen size_t.

Aus der Referenz :

Die Vorlagenspezialisierung std::hashfür die std::thread::idKlasse ermöglicht es Benutzern, Hashes der Bezeichner von Threads abzurufen.

Eine andere ID (Idee? ^^) wäre die Verwendung von Stringstreams:

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

Und verwenden Sie try catch, wenn Sie keine Ausnahme wünschen, falls etwas schief geht ...

Eine Idee wäre, den lokalen Thread-Speicher zum Speichern einer Variablen zu verwenden - egal welcher Typ, solange er den Regeln des lokalen Thread-Speichers entspricht - und dann die Adresse dieser Variablen als "Thread-ID" zu verwenden. Offensichtlich wird jede Arithmetik nicht sinnvoll sein, aber es wird ein integraler Typ sein.

Für die Nachwelt: Gibt pthread_self()a zurück pid_tund ist posix. Dies ist portabel für einige Definitionen von portabel.

gettid(), mit ziemlicher Sicherheit nicht tragbar, aber es gibt einen GDB-freundlichen Wert zurück.

Ich weiß wirklich nicht, wie schnell das geht, aber das ist die Lösung, die ich zu Gast bekommen habe:

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;

Wieder fange ich an zu denken, dass es die Antwort ist, einen Zeiger auf die Struktur zu bekommen und ihn in unsigned int oder uint64_t umzuwandeln ... 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, um höllische Probleme zu vermeiden :) Das Umschreiben ist im Vergleich zur Suche nach solchen Fehlern einfach. :) :)

thread::native_handle()gibt zurück thread::native_handle_type, was ein typedef ist long unsigned int.

Wenn der Thread standardmäßig erstellt wird, gibt native_handle () 0 zurück. Wenn ein Betriebssystem-Thread angeschlossen ist, ist der Rückgabewert ungleich Null (unter POSIX ist er pthread_t).

Auf diese Weise sollte funktionieren:

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

Denken Sie daran, Library Sstream einzuschließen

es hängt davon ab, wofür Sie die thread_id verwenden möchten; Sie können verwenden:

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

Dadurch wird während des Prozesses eine eindeutige ID generiert. Es gibt jedoch eine Einschränkung: Wenn Sie mehrere Instanzen desselben Prozesses starten und jede von ihnen ihre Thread-IDs in eine gemeinsame Datei schreibt, kann die Eindeutigkeit der thread_id nicht garantiert werden. In der Tat ist es sehr wahrscheinlich, dass Sie Überschneidungen haben. In diesem Fall können Sie Folgendes tun:

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

Jetzt sind Ihnen systemweit eindeutige Thread-IDs garantiert.

Ein Hauptgrund, thread :: get_id () nicht zu verwenden, ist, dass es in einem einzelnen Programm / Prozess nicht eindeutig ist. Dies liegt daran, dass die ID nach Abschluss des ersten Threads für einen zweiten Thread wiederverwendet werden kann.

Dies scheint eine schreckliche Funktion zu sein, aber es ist was in C ++ 11.

Eine andere Alternative:

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

Der von g ++ in x86 64-Bit generierte Code für diese Funktion lautet nur:

_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

Dh ein einzelner Zweig ohne Synchronisation, der korrekt vorhergesagt wird, außer wenn Sie die Funktion zum ersten Mal aufrufen. Danach nur noch ein einziger Speicherzugriff ohne Synchronisation.

Vielleicht ist diese Lösung für jemanden hilfreich. Nenne es ein erstes Mal im main(). Warnung: nameswächst auf unbestimmte Zeit.

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