C++ thread线程库

thread库

std::thread 是 C++ 标准库中的一个类，用于管理和控制单个执行线程。线程允许程序并行执行多个函数，从而提高性能和响应速度。std::thread 类提供了一种便捷的方式来创建和操作线程。

1、用途

并行执行任务： 通过 std::thread，可以同时执行多个函数。

多任务处理： 可以在不同的线程中处理不同的任务，使得程序可以同时完成多个任务。

资源共享和同步： 通过 std::thread，多个线程可以共享资源，如内存和文件。为避免数据竞争和冲突，通常会使用同步机制（如 std::mutex 和 std::atomic）来保护共享资源。

2、关键点

线程创建和启动： std::thread 在构造时立即开始执行提供的函数。

线程同步： joinable() 方法检查线程是否可以被 join 或 detach。调用 join() 会阻塞当前线程，直到目标线程完成。

3、线程的状态：

• 默认构造、移动构造、detach 或 join 后，std::thread 对象将不再表示任何线程。
• 两个 std::thread 对象不能表示同一执行线程，且 std::thread 不能复制，但可以移动。

一、类成员

id: 表示线程的id

std::thread::id
线程id唯一表示一个线程，一旦线程结束，这个id可以复用作为另一个线程的线程id;

二、成员函数

1、构造函数

用于构造新的thread对象

(1) 默认构造函数：构造一个不表示新线程的thread对象，即不创建新线程。

(2) 移动构造函数：将other表示的执行线程的所有权转移给新创建的线程对象thread。调用后，thread表示执行线程，而other不再表示任何线程。

(3) 函数对象和参数列表：使用给定的函数和该函数的参数列表来创建并启动一个新线程。

(4) 复制构造函数：此构造函数被删除，因此thread对象不允许复制。

1)代码测试

#include <iostream>
#include <thread>
#include <chrono>
#include <string>

void func(int num,std::string str)
{
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << str <<" " << num << ":" << std::this_thread::get_id() << std::endl;
}

void func2()
{
    std::cout << "is func2" << std::endl;
}

int main()
{
    /*未启动线程*/
    // std::thread thread1; 
    // if(thread1.joinable())
    // {
    //     std::cout << "thread1 线程可被释放" << std::endl;
    //     thread1.join(); 
    // } else{
    //     std::cout << "thread1 线程不可被释放" << std::endl;
    // }

    //std::thread thread();
    // if(thread.joinable())    // 非法使用
    // {
    //     thread.join();   // 非法使用
    // }

    /*构造并启动*/
    // std::thread thread2(func,2,"thread2");
    // if(thread2.joinable())
    // {
    //     std::cout << "thread2 线程可被释放" << std::endl;
    //     thread2.join(); 
    // } else{
    //     std::cout << "thread2 线程不可被释放" << std::endl;
    // }    

    /*使用可调用对象和参数列表*/ 
    // std::thread thread4(func,4,"thread4");
    // if(thread4.joinable())
    // {
    //     thread4.join();
    //     std::cout << "t3 线程被释放" << std::endl;
    // } else{
    //     std::cout << "t3 线程不能被释放" << std::endl;
    // }

    /*移动构造*/ 
    // std::thread thread3(func,3,"thread3");
    // std::thread move_thread = std::move(thread3);
    // if(thread3.joinable())
    // {
    //     thread3.join();
    //     std::cout << "t3 线程被释放" << std::endl;
    // } else{
    //     std::cout << "t3 线程不能被释放" << std::endl;
    // }

    // if(move_thread.joinable())
    // {
    //     move_thread.join();
    //     std::cout << "move_thread 线程被释放" << std::endl;
    // } else{
    //     std::cout << "move_thread 线程不能被释放" << std::endl;
    // }

    /*复制构造*/
    // std::thread thread5(func,5,"thread5");
    // std::thread copy_thread(thread5);
    // thread5.join();
    // if(copy_thread.joinable())
    // {
    //     copy_thread.join();
    //     std::cout << "copy_thread 线程被释放" << std::endl;
    // } else{
    //     std::cout << "copy_thread 线程不能被释放" << std::endl;
    // }

    /*使用默认构造函数，延时启动线程*/
    // std::thread thread6; // 默认构造
    // thread6 = std::thread(func,6,"thread6");
    // if(thread6.joinable())
    // {
    //     thread6.join();
    //     std::cout << "thread6 线程被释放" << std::endl;
    // } else{
    //     std::cout << "thread6 线程不能被释放" << std::endl;
    // }

    return 0;
}

2)执行结果

2、析构函数

用于销毁 thread 对象，析构之前一定要保证没有正在运行的关联线程（ 即joinable()返回true ），否则调用析构函数时会导致调用std::terminate()，从而终止程序 ，产生资源泄露和未定义行为。

注： std::terminate 函数 是一个用于处理未捕获异常的全局终止函数。当程序遇到未捕获的异常或者某些致命错误时，std::terminate 会被调用，通常会导致程序非正常退出。

在下列操作后 thread 对象无关联的线程（从而可安全销毁）

1.被默认构造，并没有被启动的线程对象
std::thread thread1;	// thread1没有被启动,则可以被安全销毁

2.被移动构造的线程对象
std::thread t2(func, argv);
std::thread t3(std::move(t2)); // 线程对象 t2 被移动后可以被安全销毁

3.调用了join()后的线程对象
t3.join();				// 线程对象 t3再调用 join()后,可以被安全销毁

4.调用了detach()后的线程对象
std::thread t4(func,argv);
t4.detach();			// 线程对象 t4 在调用detach()后可以被安全销毁

经过这些操作后，std::thread 对象不再与任何线程关联，可以安全销毁。这些操作确保在销毁 std::thread 对象时不会调用 std::terminate()。

1)代码测试

#include <iostream>
#include <thread>
#include <chrono>

void func(std::string str)
{
    std::cout << str << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
}

int main()
{
    // std::thread t1(func,"t1");
    std::thread t2(func,"t2");
    std::thread t3(std::move(t2));
    std::thread t4(func,"t4");
    t3.join();
    t4.detach();
    return 0;
}

2)执行结果

3、运算符重载operator=

operator= 实际上是一个移动赋值运算符。它执行的是移动语义，将一个线程对象的所有权从一个 std::thread 对象转移到另一个 std::thread 对象。，类比移动构造。

4、joinable

检查 std::thread 对象是否活着。 若 thread 对象表示的执行线程活着则返回 true ，否则返回 false 。

1)代码测试

std::thread t1(func,argc);
if(t1.joinable())
	std::cout << "线程存活" << std::endl;
else
	std::cout << "线程死亡" << std::endl;

t1.join();
if(t1.joinable())
	std::cout << "线程存活" << std::endl;
else
	std::cout << "线程死亡" << std::endl;

2)执行结果

5、get_id

获取与线程对象关联的线程的 ID 。

• std::this::thread::get_id(); 获取当前执行线程的ID；
• std::thread 对象调用 get_id()，获取与该对象关联的线程ID；

1)代码测试

#include <iostream>
#include <thread>
#include <thread>
#include <mutex>    // 互斥锁头文件

std::mutex mutex_lock;  // 定义互斥锁

void func(std::string str)
{
    std::lock_guard<std::mutex> lock(mutex_lock);  // 确保线程安全
    std::cout << "线程 " << str << " id = " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2)); 
}

int main()
{
    
    std::thread t1(func,"t1");
    std::thread t2(func,"t2");
    {
        std::lock_guard<std::mutex> lock(mutex_lock);  // 确保线程安全
        std::thread::id t1_id = t1.get_id();
        std::thread::id t2_id = t2.get_id();
        std::cout << "t1_id = " << t1_id << std::endl;
        std::cout << "t2_id = " << t2_id << std::endl;    
    }
    
    {
        std::lock_guard<std::mutex> lock(mutex_lock);  // 确保线程安全
        std::cout << "主线程 " << " id = " << std::this_thread::get_id() << std::endl;
    }
    t1.join();
    t2.join();
    return 0;
}

注：mutex_lock 是线程互斥锁，防止控制台输出竞争，输出信息混乱。关注get_id()函数的调用即可，使用互斥锁，是为了让了输出更美观，并获得正确的输出信息。

2)执行结果

6、native_handle

用于获取与 std::thread 对象关联的底层线程句柄。 std::thread 提供了一组基本的线程管理功能，但是在某些情况下，可能需要更低级的线程管理功能，例如设置线程优先级、绑定线程到特定的 CPU 核心、或其他特定于平台的操作。 如果需要与平台特定的 API 交互，native_handle() 可以获取底层线程句柄，从而进行更精细的控制。

1)代码测试

#include <iostream>
#include <thread>
#include <pthread.h>    // c线程库
#include <errno.h>
#include <string.h>

void func()
{
    std::cout << "thread ID = " << std::this_thread::get_id() << std::endl;
}

int main()
{
    std::thread t(func);
    pthread_t nativeHandle = t.native_handle(); // 获取底层线程句柄

    // 设置线程优先级
    sched_param sch_params;
    sch_params.sched_priority = 20; // 设置优先级
    if (pthread_setschedparam(nativeHandle, SCHED_FIFO, &sch_params)) 
    {
        std::cerr << "设置线程调度失败: " << strerror(errno) << std::endl;
    }
    t.join();
    return 0;
}

2)执行结果

注：普通用户没有权限设置优先级，可以使用 sudo 获取临时管理员权限运行。

7、hardware_concurrency

返回支持的并发线程数，这个返回值因为系统资源限制、竞争条件、硬件支持等情况，该值只能做一个参考。

1)代码测试

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

std::mutex mutex_lock;

void func(std::string str)
{
    std::lock_guard<std::mutex> lock(mutex_lock);  // 确保线程安全
    std::cout << "线程 " << str << " id = " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2)); 
}

int main()
{
    static unsigned int num = std::thread::hardware_concurrency();
    std::cout << "支持" << num << "个线程" << std::endl;
    return 0;
}

2)执行结果

8、join

用于阻塞当前线程，直到被 join() 的线程执行结束，被 join 的线程执行结束后，从对应的 join() 处返回。多个线程内，对同一个 std::thread 对象调用 join() 会导致未定义行为。

注： std::thread 对象调用 join()后，joinable() 结果为 false 。

1)代码测试

#include <iostream>
#include <thread>
#include <chrono>

void func(std::string str)
{
    std::cout << str << " " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
}

void func1(std::string str)
{
    std::cout << str << " " << std::this_thread::get_id() << std::endl;
}

int main()
{
    std::thread t(func,"线程t");
    t.join();
    std::cout << "主线程: " << std::this_thread::get_id() << std::endl;

    std::thread t1(func1,"线程t1");
    std::thread t2([&t1]{
        t1.join();
    });
    std::thread t3([&t1] {
        t1.join();
    });
    t2.join();
    t3.join();
    return 0;
}

2)执行结果

9、detach

从 std::thread 对象分离执行线程，允许被分离的线程独立持续执行。该线程退出会自行释放资源，调用 detach 不再占有任何线程。

1)代码测试

#include <iostream>
#include <thread>
#include <chrono>

void func(std::string str)
{
    std::cout << str << " " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::thread t(func,"线程t");
    std::this_thread::sleep_for(std::chrono::seconds(2));
    t.detach();
    
    if(t.joinable())
    {
        std::cout << "线程t可被释放" << std::endl;
    }else{
        std::cout << "线程t自行释放" << std::endl;
    }
    return 0;
}

2)执行结果

10、swap

用于交换两个底层 std::thread 对象的句柄。

1)代码测试

#include <iostream>
#include <thread>
#include <chrono>

void func(std::string str)
{
    std::cout << str << " " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
}

void func1(std::string str)
{
    std::cout << str << " " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
}

int main()
{
    std::thread t1(func,"t1");
    std::cout << "t1_ID = " << t1.get_id() << std::endl;
    std::thread t2(func1,"t2");
    std::cout << "t2_ID = " << t2.get_id() << std::endl;
    t1.swap(t2);
    std::cout << "t1_ID = " << t1.get_id() << std::endl;
    std::cout << "t2_ID = " << t2.get_id() << std::endl;
    t1.join();
    t2.join();
    return 0;
}

2)执行结果

参考资料：[ [std::thread - C++中文 - API参考文档 ] ]( std::thread - C++中文 - API参考文档 (apiref.com) )

如有谬误，请各位大佬指正。