C++ 线程标识

在多线程编程中，能够唯一地识别各个线程是非常重要的。C++11引入的线程库提供了简单而强大的方式来获取和使用线程标识符，这对于调试、日志记录和线程管理都非常有用。

什么是线程标识？

线程标识（Thread ID）是一个用于唯一标识线程的值。在C++标准库中，线程标识由std::thread::id类型表示，它可以：

• 唯一标识一个线程
• 用于比较线程是否相同
• 支持排序操作（用于容器中）
• 可以转换为字符串用于输出

备注

线程标识是由系统分配的，程序员不能直接为线程指定ID。每当创建一个新线程时，系统会自动为其分配一个唯一的标识符。

如何获取线程标识

C++提供了几种方式获取线程标识：

1. 使用std::thread::get_id()

对于已知的std::thread对象，可以调用其get_id()成员函数获取线程标识：

cpp

#include <iostream>
#include <thread>

void print_id() {
    std::cout << "线程 ID: " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::thread t(print_id);
    
    std::cout << "主线程 ID: " << std::this_thread::get_id() << std::endl;
    std::cout << "子线程 ID: " << t.get_id() << std::endl;
    
    t.join();
    return 0;
}

输出示例：

主线程 ID: 139925146316608
子线程 ID: 139925137927936
线程 ID: 139925137927936

2. 使用std::this_thread::get_id()

在线程执行的函数内部，可以使用std::this_thread::get_id()获取当前线程的ID：

cpp

#include <iostream>
#include <thread>
#include <vector>

void worker(int index) {
    std::cout << "工作线程 " << index << " ID: " 
              << std::this_thread::get_id() << std::endl;
}

int main() {
    std::cout << "主线程 ID: " << std::this_thread::get_id() << std::endl;
    
    std::vector<std::thread> threads;
    for (int i = 0; i < 3; ++i) {
        threads.push_back(std::thread(worker, i));
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    return 0;
}

输出示例：

主线程 ID: 140034697670400
工作线程 0 ID: 140034689281792
工作线程 2 ID: 140034672496384
工作线程 1 ID: 140034680889088

线程标识的特性

std::thread::id具有以下特性：

1. 默认构造的线程ID：表示"无线程"
2. 可比较性：支持所有比较操作符(==, !=, <, <=, >, >=)
3. 可哈希：可以用作无序容器的键
4. 可输出：可以使用std::cout直接输出

线程标识的比较

线程标识可以用来检查两个线程是否相同或者确定线程是否处于特定状态：

cpp

#include <iostream>
#include <thread>

void some_function() {
    // 线程工作
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

int main() {
    // 默认构造的线程ID表示"无线程"
    std::thread::id default_id;
    
    std::thread t1(some_function);
    std::thread t2(some_function);
    
    // 比较两个不同线程的ID
    if (t1.get_id() != t2.get_id()) {
        std::cout << "t1和t2是不同的线程" << std::endl;
    }
    
    // 检查线程是否可连接（joinable）
    if (t1.get_id() != default_id) {
        std::cout << "t1是一个活动线程" << std::endl;
    }
    
    // 等待线程完成
    t1.join();
    t2.join();
    
    return 0;
}

输出示例：

t1和t2是不同的线程
t1是一个活动线程

使用线程ID进行调试和日志记录

线程标识在调试多线程程序时非常有用，可以帮助追踪不同线程的执行：

cpp

#include <iostream>
#include <thread>
#include <mutex>
#include <sstream>

std::mutex cout_mutex;  // 保护cout的互斥量

void log_message(const std::string& message) {
    std::lock_guard<std::mutex> lock(cout_mutex);
    std::cout << "[线程 " << std::this_thread::get_id() << "] " 
              << message << std::endl;
}

void worker(int id) {
    std::ostringstream oss;
    oss << "工作线程 " << id << " 开始执行";
    log_message(oss.str());
    
    // 模拟工作
    std::this_thread::sleep_for(std::chrono::milliseconds(100 * id));
    
    oss.str("");
    oss << "工作线程 " << id << " 完成执行";
    log_message(oss.str());
}

int main() {
    log_message("主线程开始");
    
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);
    std::thread t3(worker, 3);
    
    log_message("主线程等待所有工作线程完成");
    
    t1.join();
    t2.join();
    t3.join();
    
    log_message("主线程结束");
    
    return 0;
}

输出示例：

[线程 139638496355136] 主线程开始
[线程 139638487966432] 工作线程 1 开始执行
[线程 139638479573728] 工作线程 2 开始执行
[线程 139638471181024] 工作线程 3 开始执行
[线程 139638496355136] 主线程等待所有工作线程完成
[线程 139638487966432] 工作线程 1 完成执行
[线程 139638479573728] 工作线程 2 完成执行
[线程 139638471181024] 工作线程 3 完成执行
[线程 139638496355136] 主线程结束

线程ID的存储和管理

在实际应用中，有时需要管理多个线程并通过ID识别它们。以下是一个利用std::map存储线程ID和相关信息的例子：

cpp

#include <iostream>
#include <thread>
#include <map>
#include <string>
#include <mutex>

std::mutex map_mutex;
std::map<std::thread::id, std::string> thread_names;

void register_thread(const std::string& name) {
    std::lock_guard<std::mutex> lock(map_mutex);
    thread_names[std::this_thread::get_id()] = name;
}

void print_thread_name() {
    std::lock_guard<std::mutex> lock(map_mutex);
    auto id = std::this_thread::get_id();
    auto it = thread_names.find(id);
    
    if (it != thread_names.end()) {
        std::cout << "当前线程名称: " << it->second 
                  << " (ID: " << id << ")" << std::endl;
    } else {
        std::cout << "未注册的线程 ID: " << id << std::endl;
    }
}

void worker(const std::string& name) {
    register_thread(name);
    print_thread_name();
    
    // 模拟工作
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

int main() {
    register_thread("主线程");
    print_thread_name();
    
    std::thread t1(worker, "工作线程1");
    std::thread t2(worker, "工作线程2");
    
    t1.join();
    t2.join();
    
    // 打印所有注册的线程
    std::cout << "\n所有注册的线程:" << std::endl;
    std::lock_guard<std::mutex> lock(map_mutex);
    for (const auto& pair : thread_names) {
        std::cout << pair.second << " (ID: " << pair.first << ")" << std::endl;
    }
    
    return 0;
}

输出示例：

当前线程名称: 主线程 (ID: 140358675564352)
当前线程名称: 工作线程1 (ID: 140358667175648)
当前线程名称: 工作线程2 (ID: 140358658782944)

所有注册的线程:
主线程 (ID: 140358675564352)
工作线程1 (ID: 140358667175648)
工作线程2 (ID: 140358658782944)

实际应用案例：线程池中的线程标识

在线程池实现中，线程标识可用于跟踪哪些线程正在处理任务以及它们的状态。以下是一个简化的线程池示例：

cpp

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <unordered_map>

class ThreadPool {
public:
    ThreadPool(size_t numThreads) : stop(false) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this, i] {
                // 记录线程ID和索引的映射
                {
                    std::lock_guard<std::mutex> lock(mapMutex);
                    threadIndices[std::this_thread::get_id()] = i;
                }
                
                while (true) {
                    std::function<void()> task;
                    
                    {
                        std::unique_lock<std::mutex> lock(queueMutex);
                        condition.wait(lock, [this] { 
                            return stop || !tasks.empty(); 
                        });
                        
                        if (stop && tasks.empty()) {
                            return;
                        }
                        
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    
                    // 记录当前任务由哪个线程处理
                    {
                        std::lock_guard<std::mutex> lock(coutMutex);
                        std::cout << "线程 " << std::this_thread::get_id() 
                                  << " (索引: " << i << ") 开始处理任务" 
                                  << std::endl;
                    }
                    
                    task();  // 执行任务
                    
                    {
                        std::lock_guard<std::mutex> lock(coutMutex);
                        std::cout << "线程 " << std::this_thread::get_id() 
                                  << " (索引: " << i << ") 完成任务" 
                                  << std::endl;
                    }
                }
            });
        }
    }
    
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        
        for (std::thread &worker: workers) {
            worker.join();
        }
    }
    
    template<typename F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            if (stop) {
                throw std::runtime_error("ThreadPool已停止");
            }
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }
    
    // 获取指定线程ID的索引
    int getThreadIndex(std::thread::id id) {
        std::lock_guard<std::mutex> lock(mapMutex);
        auto it = threadIndices.find(id);
        if (it != threadIndices.end()) {
            return it->second;
        }
        return -1;  // 未找到
    }
    
    // 打印当前所有线程信息
    void printThreadInfo() {
        std::lock_guard<std::mutex> lock(mapMutex);
        std::cout << "\n线程池中的线程信息:" << std::endl;
        for (const auto& pair : threadIndices) {
            std::cout << "线程 " << pair.first << " 索引: " << pair.second << std::endl;
        }
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    
    std::mutex queueMutex;
    std::mutex coutMutex;
    std::mutex mapMutex;
    std::condition_variable condition;
    std::atomic<bool> stop;
    
    // 存储线程ID和线程索引的映射
    std::unordered_map<std::thread::id, int> threadIndices;
};

int main() {
    ThreadPool pool(4);  // 创建4个线程的线程池
    
    // 等待线程启动并记录ID
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    
    // 打印线程信息
    pool.printThreadInfo();
    
    // 提交一些任务
    for (int i = 0; i < 8; ++i) {
        pool.enqueue([i] {
            std::cout << "任务 " << i << " 开始执行于线程 " 
                      << std::this_thread::get_id() << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
            std::cout << "任务 " << i << " 执行完成" << std::endl;
        });
    }
    
    // 等待任务完成
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    return 0;
}

输出示例（可能因运行环境不同而有所差异）：

线程池中的线程信息:
线程 140694092256000 索引: 0
线程 140694083863296 索引: 1
线程 140694075470592 索引: 2
线程 140694067077888 索引: 3
线程 140694092256000 (索引: 0) 开始处理任务
任务 0 开始执行于线程 140694092256000
线程 140694083863296 (索引: 1) 开始处理任务
任务 1 开始执行于线程 140694083863296
线程 140694075470592 (索引: 2) 开始处理任务
任务 2 开始执行于线程 140694075470592
线程 140694067077888 (索引: 3) 开始处理任务
任务 3 开始执行于线程 140694067077888
任务 0 执行完成
线程 140694092256000 (索引: 0) 完成任务
线程 140694092256000 (索引: 0) 开始处理任务
任务 4 开始执行于线程 140694092256000
任务 1 执行完成
线程 140694083863296 (索引: 1) 完成任务
线程 140694083863296 (索引: 1) 开始处理任务
任务 5 开始执行于线程 140694083863296
任务 2 执行完成
线程 140694075470592 (索引: 2) 完成任务
线程 140694075470592 (索引: 2) 开始处理任务
任务 6 开始执行于线程 140694075470592
任务 3 执行完成
线程 140694067077888 (索引: 3) 完成任务
线程 140694067077888 (索引: 3) 开始处理任务
任务 7 开始执行于线程 140694067077888
任务 4 执行完成
线程 140694092256000 (索引: 0) 完成任务
任务 5 执行完成
线程 140694083863296 (索引: 1) 完成任务
任务 6 执行完成
线程 140694075470592 (索引: 2) 完成任务
任务 7 执行完成
线程 140694067077888 (索引: 3) 完成任务

总结

线程标识在C++多线程编程中是一个重要概念，它为我们提供了以下功能：

1. 唯一标识：每个线程拥有唯一的标识符
2. 状态检查：可以检查线程是否在运行
3. 比较线程：可以比较不同线程是否相同
4. 调试工具：在日志记录和调试中非常有用
5. 线程管理：在线程池等高级应用中管理线程

了解和正确使用线程标识符是编写健壮、可调试多线程程序的基础。通过本文的学习，你应该已经掌握了如何获取、比较和使用线程标识符，以及在实际应用中的常见场景。

练习

为了巩固你对线程标识的理解，尝试完成以下练习：

1. 编写一个程序，创建5个线程，每个线程打印自己的ID和一个唯一的任务编号。
2. 修改上面的程序，使主线程能够根据线程ID查询该线程执行的任务编号。
3. 实现一个简单的线程监控系统，记录每个线程的启动时间、执行时间和完成状态，并能够根据线程ID查询这些信息。
4. 扩展线程池示例，添加一个功能，使其能够根据线程ID暂停和恢复特定线程的执行。

附加资源

要深入了解C++的线程标识和多线程编程，可以参考以下资源：

• C++标准库参考：std:🧵:id
• C++标准库参考：std::this_thread::get_id
• 《C++ Concurrency in Action》by Anthony Williams
• 《Effective Modern C++》by Scott Meyers (Item 35-40关于并发)

记住，线程标识只是C++多线程编程中的基础概念之一。随着你对多线程的深入学习，你会遇到更多高级概念，如互斥锁、条件变量、原子操作和内存模型等。