Cách lấy id luồng số nguyên trong c ++ 11

c ++ 11 có khả năng nhận được id luồng hiện tại, nhưng nó không thể truyền sang kiểu số nguyên:

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

sản lượng: 139918771783456

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

lỗi: ép kiểu không hợp lệ từ kiểu 'std :: thread :: id' sang kiểu 'uint64_t' giống với các kiểu khác: kiểu truyền không hợp lệ từ kiểu 'std :: thread :: id' thành kiểu 'uint32_t'

Tôi thực sự không muốn thực hiện truyền con trỏ để lấy id chủ đề số nguyên. Có một số cách hợp lý (tiêu chuẩn vì tôi muốn nó di động) để làm điều đó?

Giải pháp di động là chuyển các ID được tạo của riêng bạn vào chuỗi.

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

Các std::thread::idloại được sử dụng để so sánh chỉ, không cho số học (ví dụ như nó nói trên hộp: một định danh ). Ngay cả biểu diễn văn bản của nó được tạo ra operator<<cũng không xác định , vì vậy bạn không thể tin rằng nó là biểu diễn của một số.

Bạn cũng có thể sử dụng bản đồ các std::thread::idgiá trị cho id của riêng mình và chia sẻ bản đồ này (với đồng bộ hóa thích hợp) giữa các chuỗi, thay vì chuyển trực tiếp id.

Bạn chỉ cần làm

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

để có được một size_t.

Từ cppreference :

Sự đặc biệt của khuôn mẫu std::hashcho std::thread::idlớp cho phép người dùng có được các hàm băm của số nhận dạng của các luồng.

Một id khác (ý ​​tưởng? ^^) sẽ là sử dụng stringstreams:

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

Và sử dụng try catch nếu bạn không muốn có ngoại lệ trong trường hợp mọi thứ diễn ra không như mong muốn ...

Một ý tưởng sẽ là sử dụng lưu trữ cục bộ của luồng để lưu trữ một biến - không quan trọng loại nào, miễn là nó tuân thủ các quy tắc lưu trữ cục bộ của luồng - sau đó sử dụng địa chỉ của biến đó làm "id luồng" của bạn. Rõ ràng là bất kỳ số thừa nào sẽ không có ý nghĩa, nhưng nó sẽ là một loại tích phân.

Đối với hậu thế: pthread_self()trả về mộtpid_t và là hậu tố. Đây là tính di động đối với một số định nghĩa về di động.

gettid(), gần như chắc chắn không phải là di động, nhưng nó trả lại giá trị thân thiện với GDB.

Tôi thực sự không biết điều này nhanh như thế nào, nhưng đây là giải pháp mà tôi quản lý được:

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;

Một lần nữa, tôi bắt đầu nghĩ rằng nhận được một con trỏ đến cấu trúc và truyền nó tới unsigned int hoặc uint64_t là câu trả lời ... 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 để ngăn chặn các vấn đề quái quỷ :) Viết lại rất dễ dàng so với việc săn lùng loại lỗi này. :)

thread::native_handle()trả về thread::native_handle_type, là một định dạng cho long unsigned int.

Nếu luồng được xây dựng mặc định, native_handle () trả về 0. Nếu có một luồng OS được đính kèm với nó, giá trị trả về là khác 0 (nó là pthread_t trên POSIX).

Theo cách này, sẽ hoạt động:

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

Hãy nhớ bao gồm sstream thư viện

Một lý do chính để không sử dụng thread :: get_id () là nó không phải là duy nhất trong một chương trình / quy trình. Điều này là do id có thể được sử dụng lại cho luồng thứ hai, sau khi luồng đầu tiên kết thúc.

Đây có vẻ như là một tính năng khủng khiếp, nhưng nó là gì trong c ++ 11.

nó phụ thuộc vào những gì bạn muốn sử dụng thread_id cho; bạn có thể dùng:

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

Điều này sẽ tạo ra một id duy nhất mà bạn xử lý; nhưng có một hạn chế: nếu bạn khởi chạy một số phiên bản của cùng một quy trình và mỗi phiên bản trong số họ ghi id luồng của họ vào một tệp chung, tính duy nhất của thread_id sẽ không được đảm bảo; trên thực tế, rất có thể bạn sẽ có chồng chéo. Trong trường hợp này, bạn có thể làm như sau:

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

bây giờ bạn được đảm bảo id chủ đề duy nhất trên toàn hệ thống.

Một thay thế khác:

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

Mã được tạo cho hàm này bởi g ++ trong x86 64-bit chỉ là:

_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

Tức là một nhánh duy nhất không có bất kỳ đồng bộ hóa nào sẽ được dự đoán chính xác ngoại trừ lần đầu tiên bạn gọi hàm. Sau đó chỉ là một truy cập bộ nhớ duy nhất mà không cần đồng bộ hóa.

Có thể giải pháp này hữu ích cho ai đó. Gọi nó là lần đầu tiên tôi main(). Cảnh báo: namesphát triển vô thời hạn.

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