Cpp(七) std::thread 标准库多线程

本文详细介绍了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

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

### C++ 中多线程编程的支持 #### std::thread 的基本用法 `std::thread` 是 C++11 引入的标准库组件之一,用于创建和管理线程。它可以轻松启动一个新的线程来执行指定的任务函数。 以下是 `std::thread` 的简单示例: ```cpp #include <iostream> #include <thread> void thread_function() { std::cout << "This is a new thread." << std::endl; } int main() { std::thread t(thread_function); if (t.joinable()) { t.join(); // 等待子线程完成 } return 0; } ``` 在这个例子中,主线程会等待新创建的线程结束之后再继续运行[^2]。 --- #### std::mutex 的作用与实现方式 为了保护共享资源不被多个线程同时访问而导致数据竞争问题,C++ 提供了互斥量(`std::mutex`)。通过锁定机制防止其他线程进入临界区直到当前线程释放锁为止。 下面是一个使用 `std::mutex` 来保护全局变量的例子: ```cpp #include <iostream> #include <thread> #include <mutex> std::mutex mtx; // 定义一个互斥对象 int shared_variable = 0; void increment_with_mutex(int id) { for (int i = 0; i < 5; ++i) { std::lock_guard<std::mutex> lock(mtx); // 自动获取并释放锁 ++shared_variable; std::cout << "Thread ID: " << id << ", Value: " << shared_variable << std::endl; } } int main() { std::thread t1(increment_with_mutex, 1); std::thread t2(increment_with_mutex, 2); t1.join(); t2.join(); return 0; } ``` 这里展示了如何利用 `std::lock_guard` 对象简化手动调用 `lock()` 和 `unlock()` 方法的过程[^2]。 --- #### std::atomic 的概念及其优势 当只需要确保某些特定类型的单个操作具有原子性时,可以考虑采用更轻量级的选择——`std::atomic` 类型。相比起传统意义上的锁机制来说效率更高一些因为它们通常不会涉及操作系统级别的上下文切换开销。 例如,在计数器场景下可以直接应用如下代码片段替代之前提到过的基于互斥锁版本: ```cpp #include <iostream> #include <thread> #include <atomic> std::atomic<int> atomic_counter(0); void increment_atomic() { for (size_t i = 0; i < 1000; ++i) { atomic_counter.fetch_add(1, std::memory_order_relaxed); } } int main(){ const size_t num_threads = 8; std::vector<std::thread> threads(num_threads); for(auto& th : threads){ th=std::thread(increment_atomic); } for(auto& th : threads){ th.join(); } std::cout<<"Final counter value:"<<atomic_counter<<'\n'; return 0; } ``` 此程序段说明即使存在大量并发修改也不会破坏最终结果的一致性和准确性[^3]. --- ### 总结 以上分别介绍了三种主要针对不同需求设计出来的同步手段:如果只是想让一段代码块只允许单一时刻只有一个活跃实例去执行那么就选用 Mutex;而对于那些仅仅关心某个单独数值变化情况则推荐 Atomic 。每种方法都有各自适用范围以及优缺点所以在实际开发过程中应该依据具体情况做出最佳决策[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值