Cpp(七) std::thread 标准库多线程_thread cpp-优快云博客

本文详细介绍了C++14中的多线程使用，包括不使用线程与使用线程的区别，以及std::thread的接口如join()、detach()、get_id()和swap()。还探讨了mutex和lock_guard在同步中的作用，展示了线程池的概念，并通过示例展示了如何创建线程池。最后讨论了如何向线程传递参数，包括普通参数和引用类型参数的处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

C++ 多线程

#1 环境

C++14
CMake 3.17
macOS 10.15.5
Clion

#2 开始

#2.1 不使用线程

#include <iostream>
#include <thread>

void func1(){
    std::cout << "func1" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // 休眠
}
void func2(){
    std::cout << "func2" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // 休眠
}

int main() {
    std::cout << "Hello, Thread!" << std::endl;
    func1();
    func2();
    return 0;
}

现象:

先打印输出func1两秒后再打印输出func2,再过两秒后退出程序

#2.2 使用多线程

#include <iostream>
#include <thread>

void func1(){
    std::cout << "func1" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // 休眠
}
void func2(){
    std::cout << "func2" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // 休眠
}

int main() {
    std::cout << "Hello, Thread!" << std::endl;
    std::thread t1(func1);
    std::thread t2(func2);
    t1.join();
    t2.join();
    return 0;
}

现象:

几乎同时打印输出func1 func2, 两秒后退出程序

#3 std::thread 接口

#3.1 std::thread t1(func1)

std::thread: 变量类型
t1: 多线程变量名
func1: 需要执行的方法

#3.2 t1.join();

连接

std::thread t1(func1);
t1.join();

join(): 阻塞等func1执行完毕后返回

#3.3 t1.detach();

分离

std::thread t1(func1);
t1.detach();

detach(): 不阻塞,直接返回

#3.4 get_id()

获取线程id

std::thread t1(func1);
std::thread::id t1_id = t1.get_id();
std::cout << "t1 id:" << t1_id << std::endl;

#3.5 swap()

交换两个线程对象所代表的底层句柄(underlying handles)。

std::thread t1(func1);
std::thread t2(func2);
std::cout << "t1 id:" << t1.get_id() << std::endl;
std::cout << "t2 id:" << t2.get_id()<< std::endl;
std::swap(t1, t2);
std::cout << "t1 id:" << t1.get_id() << std::endl;
std::cout << "t2 id:" << t2.get_id()<< std::endl;
t1.join();
t2.join();

# output
Hello, Thread!
t1 id:0x7000069c8000
t2 id:0x700006a4b000
t1 id:0x700006a4b000
t2 id:0x7000069c8000
func1
func2

#3.6 mutex()

mutex是用来保证线程同步的，防止不同的线程同时操作同一个共享数据。

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

int count = 10;
std::mutex lock;

void func1(){
    while (count>0){
        lock.lock();
        count--;
        std::cout << count << std::endl;
        lock.unlock();
    }
}
void func2(){
    while (count>0){
        lock.lock();
        count--;
        std::cout << count << std::endl;
        lock.unlock();
    }
}

int main() {
    std::thread t1(func1);
    std::thread t2(func2);
    t1.join();
    t2.join();
    return 0;
}

# output
9
8
7
6
5
4
3
2
1
0
-1

但是使用mutex是不安全的，当一个线程在解锁之前异常退出了，那么其它被阻塞的线程就无法继续下去。

#3.7 lock_guard

使用lock_guard则相对安全，它是基于作用域的，能够自解锁，当该对象创建时，它会像m.lock()一样获得互斥锁，当生命周期结束时，它会自动析构(unlock)，不会因为某个线程异常退出而影响其他线程

...
while (count>0){
    std::lock_guard<std::mutex> lk(lock);
    count--;
    std::cout << count << std::endl;
}
...

#4 线程池

线程的创建和销毁会消耗系统资源,为了避免系统的消耗,加入线程池概念,为的就是创建的线程存到队列中,线程执行结束后,不销毁,等到下一个申请线程时,从队列中取出已有的线程

这里使用GitHub上已经写好的第三方线程池库

GItHub地址: https://github.com/progschj/ThreadPool

#include <iostream>
#include <thread>
#include <mutex>
#include "ThreadPool.h"

void func1(){
    std::cout << "func1: " << std::this_thread::get_id() << " :func1"  << std::endl; // 打印当前线程id
    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // 休眠
}
void func2(){
    std::cout << "func2: " << std::this_thread::get_id() << " :func2" << std::endl; // 打印当前线程id 
    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // 休眠

}

int main() {
    ThreadPool pool(4); // 线程池最大线程数为4 
    pool.enqueue(func1);
    pool.enqueue(func1);
    pool.enqueue(func2);
    pool.enqueue(func2);
    pool.enqueue(func2); // 创建5个线程, 只要有两个线程的id相同,就能证明线程池可用
    return 0;
}

# output
func1: func1: func2: 0x700002a07000 :func20x700002901000 :func1
func2: 0x700002984000 :func1
0x700002a8a000 :func2
func2: 0x700002901000 :func2

有两个线程的id为0x700002901000,证明线程池可用

#5 传参数

#5.1 普通传参数

class MyThread{
public:
    static void func_1(int a){
        std::cout << "func_1: " << a << std::endl;
    }
};

int main() {
    std::make_shared<std::string>("hello");
    std::thread t1(&MyThread::func_1,1);
    t1.join();

    return 0;
}

# output
func_1: 1

目标线程函数,必须是static(类方法)

#5.2 参数是引用类型

class MyThread{
public:
    static void func_2(std::shared_ptr<std::string> &a){
        std::cout << "func_2: " << a << std::endl;
    }
};

int main() {
    std::shared_ptr<std::string> pt = std::make_shared<std::string>("hello");
    std::thread t2(&MyThread::func_2,pt);
    t2.join();

    return 0;
}

func_2中的形参是一个引用类型,如果直接传参数,编译会报错

typedef typename result_of<_Callable(_Args...)>::type result_type;
                                                             ^
/usr/include/c++/5/functional:1526:9: error: no type named ‘type’ in ‘class std:

在这里插入图片描述

class MyThread{
public:
    static void func_2(std::shared_ptr<std::string> &a){
        std::cout << "func_2: " << a << std::endl;
    }
};

int main() {
    std::shared_ptr<std::string> pt = std::make_shared<std::string>("hello");
    std::thread t2(&MyThread::func_2,std::ref(pt)); // 传引用 
    t2.join();

    return 0;
}

# output
func_2: 0x7fcd38405808

因为多线程是抢占式(多线程的全局变量需要加互斥锁),引用的生命周期和多线程的生命周期不一致,在线程结束时,引用变量依然会存在,但是,正常来说,程序员会认为,一个线程结束后,相关的变量也会被销毁,程序员这样的思维与引用违背,所以,多线程传参数时,默认是传值,而不是传引用,如果真的需要传引用,需要特殊的处理(为了提醒程序员,当前传的是引用)