【C++ 包裹类 std::thread】探索C++11 std::thread：如何使用它来创建、销毁和管理线程
std::thread
- std::thread 构造函数
- std::thread 赋值操作
- std::thread其他成员函数
- `get_id`: 获取线程 ID
- `joinable`: 检查线程是否可被 join
- `detach`: Detach 线程
- `join`: Detach 线程
- `swap`: Swap 线程
- `native_handle:` 返回 native handle
- `hardware_concurrency` \[static]
- std::this_thread 命名空间中相关辅助函数
- std::thread的可联结性
- std::thread 对象析构
- std::thread的注意事项
- std::thread 实现一个简单的线程池示例
- 封装一个功能全面的std::thread 类
std::thread 构造函数
//默认构造函数 thread() noexcept; //初始化构造函数 template <class Fn, class... Args> explicit thread(Fn&& fn, Args&&... args); //拷贝构造函数 [deleted] thread(const thread&) = delete; //Move 构造函数 thread(thread&& x) noexcept;
- 默认构造函数，创建一个空的
std::thread执行对象。- 初始化构造函数，创建一个
std::thread对象，该std::thread对象可被joinable，新产生的线程会调用fn函数，该函数的参数由args给出。- 拷贝构造函数(被禁用)，意味着
std::thread对象不可拷贝构造。- Move 构造函数，move 构造函数(move 语义是 C++11 新出现的概念，详见附录)，调用成功之后
x不代表任何std::thread执行对象。
- 📌注意：可被
joinable的std::thread对象必须在他们销毁之前被主线程join或者将其设置为detached.
std::thread 赋值操作
//Move 赋值操作 thread& operator=(thread&& rhs) noexcept; //拷贝赋值操作 [deleted] thread& operator=(const thread&) = delete;
- Move 赋值操作(1)，如果当前对象不可
joinable，需要传递一个右值引用(rhs)给move赋值操作；如果当前对象可被joinable，则会调用terminate() 报错。- 拷贝赋值操作(2)，被禁用，因此
std::thread对象不可拷贝赋值。
- 示例
#include#include #include // std::chrono::seconds#include // std::cout#include // std::thread, std::this_thread::sleep_forvoid thread_task(int n) {std::this_thread::sleep_for(std::chrono::seconds(n));std::cout << "hello thread "<< std::this_thread::get_id()<< " paused " << n << " seconds" << std::endl;}int main(int argc, const char *argv[]){std::thread threads[5];std::cout << "Spawning 5 threads...\n";for (int i = 0; i < 5; i++) {threads[i] = std::thread(thread_task, i + 1);}std::cout << "Done spawning threads! Now wait for them to join\n";for (auto& t: threads) {t.join();}std::cout << "All threads joined.\n";return EXIT_SUCCESS;}
std::thread其他成员函数
get_id: 获取线程 ID
- 如果该std::thread是joinable状态(joinable状态后面会提到)，那么就返回一个独一无二的(unique)的当前std::thread的id(std::thread::id).
- 如果该std::thread是not joinable状态，返回std::thread::id();
joinable: 检查线程是否可被 join
该函数返回一个
bool值：
- 如果当前
std::thread对象是default-constructor构造出来的返回false.- 如果当前
std::thread对象被移动到了其他std::thread对象返回false.- 如果当前
std::thread对象的detach()和join()被调用过了返回false.
检查当前的线程对象是否表示了一个活动的执行线程，由默认构造函数创建的线程是不能被 join 的。
另外，如果某个线程 已经执行完任务，但是没有被 join 的话，该线程依然会被认为是一个活动的执行线程，因此也是可以被 join 的。
detach: Detach 线程
Detach 线程。 将当前线程对象所代表的执行实例与该线程对象分离，使得线程的执行可以单独进行。一旦线程执行完毕，它所分配的资源将会被释放。
调用 detach 函数之后：
*this不再代表任何的线程执行实例。- joinable() == false
- get_id() == std::thread::id()
📌另外，如果出错或者
joinable() == false，则会抛出std::system_error。
join: Detach 线程
block(阻塞)调用join()的线程，直到std::thread所在的线程完成，与此同时std::thread独显被设置为not joinable.
swap: Swap 线程
Swap 线程，交换两个线程对象所代表的底层句柄(underlying handles)。
native_handle: 返回 native handle
返回 native handle（由于 std::thread 的实现和操作系统相关，因此该函数返回与 std::thread 具体实现相关的线程句柄，例如在符合 Posix 标准的平台下(如 Unix/Linux)是 Pthread 库）。
- 示例
#include#include #include #include #include std::mutex iomutex;void f(int num){std::this_thread::sleep_for(std::chrono::seconds(1));sched_param sch;int policy; pthread_getschedparam(pthread_self(), &policy, &sch);std::lock_guard<std::mutex> lk(iomutex);std::cout << "Thread " << num << " is executing at priority "<< sch.sched_priority << '\n';}int main(){std::thread t1(f, 1), t2(f, 2);sched_param sch;int policy; pthread_getschedparam(t1.native_handle(), &policy, &sch);sch.sched_priority = 20;if(pthread_setschedparam(t1.native_handle(), SCHED_FIFO, &sch)) {std::cout << "Failed to setschedparam: " << std::strerror(errno) << '\n';}t1.join();t2.join();}
hardware_concurrency [static]
检测硬件并发特性，返回当前平台的线程实现所支持的线程并发数目，但返回值仅仅只作为系统提示(hint)。
- 示例
#include#include int main() {unsigned int n = std::thread::hardware_concurrency();std::cout << n << " concurrent threads are supported.\n";}
std::this_thread 命名空间中相关辅助函数
get_id:返回一个独一无二的当前线程的ID（一般也就是unsigned int类型).yield: 使正在处于运行状态的该线程，回到可运行状态，以允许其他具有相同优先级的线程获得先执行的机会。但是很有可能该线程刚刚回到可执行状态又被再次执行。sleep_until: 线程休眠至某个指定的时刻(time point)，该线程才被重新唤醒sleep_for: 线程休眠某个指定的时间片(time span)，该线程才被重新唤醒，不过由于线程调度等原因，实际休眠时间可能比 sleep_duration 所表示的时间片更长。
std::thread的可联结性
一个 std::thread 对象只可能处于可联结或不可联结两种状态之一。即 std::thread 对象是否与某个有效的底层线程关联。
- 可联结：当线程可运行、已经运行或处于阻塞时是可联结的。但如果某个底层线程已经执行完任务，但是没有被 join 的话，该线程依然会被认为是一个活动的执行线程，仍然处于 joinable 状态。
- 不可联结：不带参构造的
std::thread对象为不可联结，因为底层线程还没创建；已经移动的std::thread对象为不可联结；已经调用join或detach的对象为不可联结状态。joinable()：判断是否可以成功使用join()或者detach()，返回true 表示可以，否则返回false
std::thread 对象析构
std::thread 对象析构时，会先判断
joinable()，如果可联结，则程序会直接被终止（terminate）。
因此，在创建 thread 对象以后，要在随后的某个地方显式地调用 join 或 detach 以便让std::thread处于不可联结状态。
std::thread的注意事项
- 在创建线程时，要确保传递给线程的函数或可调用对象的生命周期至少和线程一样长，否则可能会导致未定义行为或访问非法内存。
- 不要在多个线程中共享数据，除非你已经确保线程安全，否则可能会导致竞态条件和数据竞争。
- 在创建线程时，要注意线程的优先级和调度策略，这可能会影响程序的性能和响应时间。
- 要注意线程的同步和通信，可以使用互斥锁、条件变量等同步机制来确保线程之间的正确交互。
- 避免在程序退出前没有结束线程，这可能会导致资源泄漏或程序挂起。
- 使用std::thread时，要遵守RAII（Resource Acquisition Is Initialization）原则，确保资源的正确释放。
- 在使用std::thread时，要了解可移植性问题，因为不同操作系统和编译器可能有不同的实现细节。
总之，要注意线程的生命周期、同步和通信、资源管理等问题，才能确保使用std::thread的安全和有效。
std::thread 实现一个简单的线程池示例
#include 在这个例子中，线程池类ThreadPool包含了一个线程向量，一个任务队列，一个互斥量和一个条件变量。构造函数会创建指定数量的线程，并将它们设为等待任务。添加任务的函数add_task将函数和参数绑定为一个可调用对象，并用std::function包装成一个任务添加到队列中。添加任务后通过condition_variable通知等待的线程来处理任务。当析构函数被调用时，将设置标志stop_并通知所有线程退出。
封装一个功能全面的std::thread 类
#ifndef THREADWRAPPER_H
#define THREADWRAPPER_H
#include & func) // 描述: 设置线程的主函数// 参数: func - 线程执行的函数// 返回值: 无inline void setmain(const std::function<void()>& func) {m_mainFunc = func;}// 函数: getThread()// 描述: 返回线程对象的引用// 参数: 无// 返回值: 线程对象的引用inline std::thread& getThread() {return m_thread_;}// 函数: detach()// 描述: 设置线程的分离状态，分离状态的线程在终止时会自动清理其资源// 参数: 无// 返回值: 无inline void detach() {if (m_thread_.joinable()) {m_thread_.detach();}}// 函数: getlimit(size_t stackSize)// 描述: 设置线程的栈大小// 参数: stackSize - 栈大小（字节）// 返回值: 无inline void getlimit(size_t &stackSize) {this->executeIfRunning([&]() {_getlimit(stackSize);});}// 函数: setname(const std::string& name)// 描述: 设置线程名称// 参数: name - 线程名称// 返回值: 无void setName(const std::string& name) {m_name = name;this->executeIfRunning([&]() {_setName(name);});}// 函数: setAffinity(const std::vector& cpus) // 描述: 设置线程的CPU亲和性// 参数: cpus - 要绑定的CPU核心序列// 返回值: 无 void setAffinity(const std::vector<int>& cpus) {this->executeIfRunning([&]() {_setAffinity(cpus);}); }
// Function: setPriority
// Description: Set the scheduling policy and priority of the thread
// Parameters:
// policy - The scheduling policy (ignored on Windows)
// priority - The priority of the thread (1 to 7, where 1 is lowest and 7 is highest)
// Returns: None void setPriority(int policy,int priority) {this->executeIfRunning([&]() {_setPriority(policy,priority);});}// 函数: setSignalMask(const std::vector& signals) // 描述: 设置线程信号屏蔽集,Windows并没有类似于Linux中的信号处理机制，它使用的是事件和消息机制。// 参数: signals - 要屏蔽的信号列表// 返回值: 无 void setSignalMask(const std::vector<int>& signals) {
#ifndef _WIN32sigset_t signal_mask;sigemptyset(&signal_mask);for (const auto& sig : signals) {sigaddset(&signal_mask, sig);}int result = pthread_sigmask(SIG_BLOCK, &signal_mask, nullptr);if (result != 0) {throw std::runtime_error("Failed to set thread signal mask.");}
#endif}
private:// Function: executeIfRunning// Description: Executes a function if the thread is running// Parameters:// func - The function to execute// Returns: Nonevoid executeIfRunning(std::function<void()> func) {if (m_isRunning.load(std::memory_order_acquire)) {func();} else {std::cerr << "Thread is not running." << std::endl;}}void _getlimit(size_t &stackSize) {
#ifdef _WIN32DWORD dwStackSize = 0;if (GetThreadStackLimits(&dwStackSize, &stackSize)) {std::cout << "Thread stack size: " << stackSize << std::endl;} else {std::cerr << "Failed to get thread stack size." << std::endl;}
#elsepthread_attr_t attr;if (pthread_getattr_np(m_thread_.native_handle(), &attr) == 0) {if (pthread_attr_getstacksize(&attr, &stackSize) == 0) {std::cout << "Thread stack size: " << stackSize << std::endl;} else {std::cerr << "Failed to get thread stack size." << std::endl;}pthread_attr_destroy(&attr);} else {std::cerr << "Failed to get thread attributes." << std::endl;}
#endif}void _setName(const std::string& name) {
#ifdef _WIN32std::wstring wname(m_name.begin(), m_name.end());SetThreadDescription(m_thread_.native_handle(), wname.c_str());
#elsestd::string short_name = m_name.substr(0, 15);int result = pthread_setname_np(m_thread_.native_handle(), short_name.c_str());if (result != 0) {throw std::runtime_error("Failed to set thread name.");}
#endif}
// Function: setPriority
// Description: Set the scheduling policy and priority of the thread
// Parameters:
// policy - The scheduling policy (ignored on Windows)
// priority - The priority of the thread (1 to 7, where 1 is lowest and 7 is highest)
// Returns: None void _setPriority(int policy,int priority) {
#ifdef _WIN32// Check if the priority is in the valid rangeif (priority < 1 || priority > 7) {throw std::runtime_error("Invalid priority value.");}// Convert POSIX priority to Windows priorityint win_priority;switch (priority) {case 1: win_priority = THREAD_PRIORITY_IDLE; break;case 2: win_priority = THREAD_PRIORITY_LOWEST; break;case 3: win_priority = THREAD_PRIORITY_BELOW_NORMAL; break;case 4: win_priority = THREAD_PRIORITY_NORMAL; break;case 5: win_priority = THREAD_PRIORITY_ABOVE_NORMAL; break;case 6: win_priority = THREAD_PRIORITY_HIGHEST; break;case 7: win_priority = THREAD_PRIORITY_TIME_CRITICAL; break;default: throw std::runtime_error("Invalid priority value.");}if (!SetThreadPriority(reinterpret_cast<HANDLE>(m_thread_.native_handle()), win_priority)) {throw std::runtime_error("Failed to set thread priority.");}
#else// Check if the policy is validif (policy != SCHED_FIFO && policy != SCHED_RR && policy != SCHED_OTHER) {throw std::runtime_error("Invalid scheduling policy.");}// Check if the priority is in the valid range for the given policyint min_priority = sched_get_priority_min(policy);int max_priority = sched_get_priority_max(policy);if (priority < min_priority || priority > max_priority) {throw std::runtime_error("Invalid priority value.");}sched_param sch_params;sch_params.sched_priority = priority;int result = pthread_setschedparam(m_thread_.native_handle(), policy, &sch_params);if (result != 0) {throw std::runtime_error("Failed to set thread priority.");}
#endif
}// 函数: setAffinity(const std::vector& cpus) // 描述: 设置线程的CPU亲和性// 参数: cpus - 要绑定的CPU核心序列// 返回值: 无 void _setAffinity(const std::vector<int>& cpus) {unsigned int num_cores = std::thread::hardware_concurrency();if (num_cores == 0) {throw std::runtime_error("Failed to determine the number of available cores.");}
#ifdef _WIN32DWORD_PTR mask = 0;for (const auto& cpu : cpus) {if (cpu < 0 || static_cast<unsigned int>(cpu) >= num_cores) {throw std::runtime_error("Invalid core number specified.");}mask |= (1 << cpu);}DWORD_PTR result = SetThreadAffinityMask(m_thread_.native_handle(), mask);if (result == 0) {throw std::runtime_error("Failed to set thread CPU affinity.");}
#elsecpu_set_t cpuset;CPU_ZERO(&cpuset);for (const auto& cpu : cpus) {if (cpu < 0 || static_cast<unsigned int>(cpu) >= num_cores) {throw std::runtime_error("Invalid core number specified.");}CPU_SET(cpu, &cpuset);}int result = pthread_setaffinity_np(m_thread_.native_handle(), sizeof(cpu_set_t), &cpuset);if (result != 0) {throw std::runtime_error("Failed to set thread CPU affinity.");}
#endif
}std::thread m_thread_; // 线程对象std::function<void()> m_mainFunc; // 线程的主函数std::string m_name; // 线程名称std::atomic<bool> m_isRunning; // Atomic flag to track if the thread is running};#endif阅读我的CSDN主页,解锁更多精彩内容:泡沫的CSDN主页
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！