C++笔记之获取线程ID以及线程ID的用处
code review!
文章目录
- C++笔记之获取线程ID以及线程ID的用处
- 一.获取ID
- 二.线程ID的用处
- 2.1.线程池管理
- 2.2.动态资源分配
- 2.3.使用线程同步机制实现互斥访问共享资源
- 2.4.使用线程 ID 辅助线程同步
- 2.5.任务分发：线程ID可以用于将任务分发给不同的线程。例如，一个任务队列可以分发任务给一组线程，并使用线程ID来跟踪任务的状态和进度。
- 2.6.线程间通信：线程可以使用线程ID来识别接收消息的线程。这可用于实现多线程间的消息传递或共享数据。
一.获取ID
std::this_thread::get_id() 是 C++ 标准库中的一个函数，用于获取当前线程的唯一标识符。这个标识符通常是一个对象，它可以与其他线程的标识符进行比较，以确定它们是否代表同一线程。
以下是 std::this_thread::get_id() 的基本用法：
#include <iostream>
#include <thread>
int main() {
// 获取当前线程的标识符
std::thread::id threadId = std::this_thread::get_id();
// 将标识符打印到标准输出
std::cout << "Thread ID: " << threadId << std::endl;
return 0;
}
在上面的示例中，std::this_thread::get_id() 被用来获取当前线程的标识符，并将其打印到标准输出。这个标识符通常是一个唯一的值，可以用来区分不同的线程。
请注意，std::this_thread::get_id() 返回的是一个 std::thread::id 类型的对象，可以使用 == 或 != 运算符来比较两个线程的标识符，以确定它们是否相同。这对于多线程编程中的线程管理和同步非常有用。
上面的例子获取的是主线程的 ID。在 main 函数中调用 std::this_thread::get_id() 会返回主线程的唯一标识符。在多线程应用程序中，每个线程都有自己的唯一标识符，包括主线程。你可以在任何线程中使用 std::this_thread::get_id() 来获取该线程的标识符，不仅仅是主线程。
如果你在多线程程序中创建了其他线程，你可以在这些线程中使用 std::this_thread::get_id() 来获取它们各自的标识符，以便在需要时进行线程识别和管理。每个线程都有自己的标识符，这有助于区分和跟踪线程的行为。
二.线程ID的用处
2.1.线程池管理
在线程池中，线程 ID 可以帮助你识别特定工作者线程。例如，你可以将任务分配给特定的线程，以便更精确地控制资源分配和任务调度。
#include <iostream>
#include <thread>
#include <vector>
#include <functional>
#include <future>
void worker(int id) {
std::cout << "Worker " << id << " is executing." << std::endl;
// 执行任务
}
int main() {
int numThreads = 4;
std::vector<std::thread> threads;
for (int i = 0; i < numThreads; ++i) {
threads.push_back(std::thread(worker, i));
}
// 等待所有工作者线程完成
for (auto& thread : threads) {
thread.join();
}
std::cout << "All workers finished." << std::endl;
return 0;
}
在这个示例中，线程 ID 有助于标识线程池中的不同工作者线程。
2.2.动态资源分配
线程 ID 可以用于动态分配资源给不同的线程。例如，你可以为特定线程分配不同的计算资源或内存区域，以提高性能或实现隔离。
#include <iostream>
#include <thread>
void worker(int id) {
// 执行需要大量内存的计算任务
// 分配特定的内存区域
std::cout << "Worker " << id << " is executing." << std::endl;
// 释放内存区域
}
int main() {
int numThreads = 4;
std::vector<std::thread> threads;
for (int i = 0; i < numThreads; ++i) {
threads.push_back(std::thread(worker, i));
}
for (auto& thread : threads) {
thread.join();
}
std::cout << "All workers finished." << std::endl;
return 0;
}
对于线程 ID 用于动态分配资源的示例，考虑以下情况：你希望为不同的线程分配不同的计算资源以优化性能。在这种情况下，你可以使用线程 ID 来识别和区分不同的线程，并为它们分配不同的资源。以下是一个示例：
#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
#include <chrono>
// 模拟不同线程需要不同计算资源的任务
void performTask(int id) {
std::cout << "Thread " << id << " is performing a task." << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(2));
std::cout << "Thread " << id << " completed the task." << std::endl;
}
int main() {
int numThreads = 4;
std::vector<std::thread> threads;
for (int i = 0; i < numThreads; ++i) {
// 根据线程 ID 分配不同的计算资源
if (i % 2 == 0) {
threads.push_back(std::thread(performTask, i));
} else {
// 为奇数线程分配更多的计算资源
threads.push_back(std::thread([i] {
// 分配更多的计算资源
performTask(i);
}));
}
}
for (auto& thread : threads) {
thread.join();
}
std::cout << "All threads finished." << std::endl;
return 0;
}
在这个示例中，有四个线程执行任务，但奇数线程（线程1和线程3）被分配更多的计算资源。通过线程 ID（i）的奇偶性来确定分配不同计算资源的策略。
请注意，这个示例是一个简化的演示，真实的资源分配通常更复杂。线程 ID 可以用于更复杂的分配策略，例如在多核处理器上优化计算资源分配，或在不同的线程之间实现资源隔离。
2.3.使用线程同步机制实现互斥访问共享资源
线程同步是多线程编程中的一个关键概念，它用于确保多个线程能够安全地协同工作，避免数据竞争和并发问题。线程 ID 可以在线程同步中发挥重要作用，以下是一个示例说明线程同步的用途：
示例：使用线程同步机制实现互斥访问共享资源
在多线程环境中，多个线程可能会同时访问共享资源，如果不进行同步，会导致数据竞争和不确定的行为。为了解决这个问题，我们可以使用互斥锁（std::mutex）来保护共享资源，同时使用线程 ID 来标识哪个线程拥有锁。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx; // 用于保护共享资源的互斥锁
void worker(int id) {
// 一些工作
// 使用互斥锁来保护共享资源
mtx.lock();
std::cout << "Worker " << id << " is accessing the shared resource." << std::endl;
// 模拟工作
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "Worker " << id << " finished accessing the shared resource." << std::endl;
mtx.unlock();
}
int main() {
int numThreads = 4;
std::vector<std::thread> threads;
for (int i = 0; i < numThreads; ++i) {
threads.push_back(std::thread(worker, i));
}
for (auto& thread : threads) {
thread.join();
}
std::cout << "All workers finished." << std::endl;
return 0;
}
在上面的示例中，多个工作者线程（Worker 0、Worker 1、Worker 2、Worker 3）同时访问一个共享资源。互斥锁 mtx 用于保护共享资源，确保一次只有一个线程可以访问。线程 ID 用于标识哪个线程当前拥有锁并在访问共享资源时进行输出。
线程同步是确保多线程程序安全运行的关键部分，使用线程 ID 和互斥锁可以帮助你实现正确的线程同步。这有助于防止并发问题，如竞态条件和数据竞争，从而确保多线程程序的可靠性。
2.4.使用线程 ID 辅助线程同步
线程 ID 并不是直接用于线程同步的工具，而是用于标识不同的线程。然而，线程同步机制（如互斥锁、条件变量等）通常需要用到线程 ID 来实现更复杂的同步逻辑。下面是一个示例，演示如何使用线程 ID 来辅助线程同步。
示例：使用线程 ID 辅助线程同步
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx; // 互斥锁
std::condition_variable cv; // 条件变量
int sharedData = 0;
void worker(int id) {
std::unique_lock<std::mutex> lock(mtx);
// 等待主线程发送信号
cv.wait(lock, [id] { return id == 1; });
// 执行工作
std::cout << "Worker " << id << " is accessing shared data: " << sharedData << std::endl;
sharedData += id;
std::this_thread::sleep_for(std::chrono::seconds(1));
// 释放锁
lock.unlock();
}
int main() {
std::thread t1(worker, 1);
std::thread t2(worker, 2);
// 等待一段时间
std::this_thread::sleep_for(std::chrono::seconds(2));
// 向线程1发送信号
{
std::unique_lock<std::mutex> lock(mtx);
std::cout << "Main thread is sending a signal to Worker 1." << std::endl;
cv.notify_all();
}
t1.join();
t2.join();
std::cout << "All workers finished." << std::endl;
return 0;
}
在这个示例中，有两个工作者线程（Worker 1 和 Worker 2）。线程 1首先被阻塞在条件变量上等待一个特定信号，然后主线程向线程 1 发送信号，线程 1被唤醒后可以开始执行工作。线程 2只是简单地等待。
线程同步机制包括互斥锁 mtx 和条件变量 cv。线程 ID（id）用于确定哪个线程应该在条件变量上等待信号。线程同步的核心思想是确保线程在正确的时间点执行，并且不会出现竞争条件。
这个示例使用线程 ID 辅助线程同步，但实际上线程同步可能涉及更复杂的逻辑和多个线程之间的交互，线程 ID 通常是用于确定特定线程的条件是否满足，从而执行或等待。
2.5.任务分发：线程ID可以用于将任务分发给不同的线程。例如，一个任务队列可以分发任务给一组线程，并使用线程ID来跟踪任务的状态和进度。
线程ID可以用于将任务分发给不同的线程。例如，一个任务队列可以分发任务给一组线程，并使用线程ID来跟踪任务的状态和进度。
# Python 示例
from threading import Thread
def worker(task_id):
# 执行任务
print(f"线程 {task_id} 正在执行任务")
# 创建多个线程并分发任务
threads = []
for i in range(5):
thread = Thread(target=worker, args=(i,))
threads.append(thread)
thread.start()
# 等待所有线程完成
for thread in threads:
thread.join()
2.6.线程间通信：线程可以使用线程ID来识别接收消息的线程。这可用于实现多线程间的消息传递或共享数据。
// C++ 示例
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;
void sendMessage(int senderID, int receiverID, const std::string& message) {
std::lock_guard<std::mutex> lock(mtx);
std::cout << "线程 " << senderID << " 向线程 " << receiverID << " 发送消息: " << message << std::endl;
}
int main() {
std::thread thread1(sendMessage, 1, 2, "Hello from Thread 1!");
std::thread thread2(sendMessage, 2, 1, "Hi from Thread 2!");
thread1.join();
thread2.join();
return 0;
}
这些示例演示了如何使用线程ID来实现线程同步、任务分发和线程间通信。线程ID用于唯一标识线程，并允许线程之间进行通信和协作。请注意，具体的线程ID分配和使用方式可能因编程语言和操作系统而异。
