【施磊C++】多线程基础

原创 已于 2024-10-09 22:47:25 修改 · 805 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
施磊C++

当前文章被收录于：

施磊C++
10 篇文章 0 人学习

施磊老师C++课程笔记

订阅专栏 查看详情
于 2024-10-04 11:25:04 首次发布

目录

前言

本文介绍了C++多线程编程的基础知识，基于施磊老师的C++课程。

一、线程基础知识

C++提供了语言级别的线程库thread，支持跨平台使用，传入相应的函数以及参数即可使用：

#include <iostream>
#include <thread>

void func(int time) {
    std::this_thread::sleep_for(std::chrono::seconds(time));
    std::cout << "func()" << std::endl;
}

int main()
{
    std::thread t(func, 2);
    t.join();

    return 0;
}

join：主线程会等待子线程结束，继续执行之后的代码
detach:将主线程和子线程分离，主线程不用等待子线程结束

注意join和detach是必要的，至少有一个。因为不能确保主线程和子线程的执行顺序，如果主线程先结束，而二者又没有分离，那么就会出现问题。

二、线程间互斥

竞态条件：多线程程序执行的结果是一致的，不会随着CPU对线程不同的调用顺序，产生不同的运行结果。

lock_guard：相当于scoped_ptr
unique_lock：相当于unique_ptr

CAS

volatile关键字

三、线程间同步通信

线程间互斥：
竞态条件 -> 临界区代码段 -> 保证原子操作 -> 互斥锁mutex或者CAS
线程间同步通信：
不同的线程操作可能存在先后顺序的依赖关系，如线程B需要等待线程A完成某个操作后才能继续操作，这时就需要线程间的同步通信机制。基于互斥锁和条件变量解决生产者和消费者问题：

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
using namespace std;

// 定义互斥锁，作线程间的互斥
std::mutex mtx;
// 定义条件变量，作线程间的同步通信
std::condition_variable cv;

class Queue {
public:
    void put(int val) {
        // lock_guard<std::mutex> guard(mtx);
        unique_lock<std::mutex> lck(mtx);
        while (!que.empty()) {
            /*
            que不为空，生产者应当通知消费者去消费，消费完了，再继续生产
            生产者此时进入等待状态，并且把mtx互斥锁释放掉
            */
            cv.wait(lck);
        }
        que.push(val);
        // 通知其他所有线程进行消费
        cv.notify_all();
        cout << "生产者 生产：" << val << endl;
    }
    int get() {
        // lock_guard<std::mutex> guard(mtx);
        unique_lock<std::mutex> lck(mtx);
        while (que.empty()) {
            /*
            进入等待状态，并把mtx互斥锁释放
            */
            cv.wait(lck);
        }
        int val = que.front();
        que.pop();
        cv.notify_all();
        cout << "消费者 消费：" << val << endl;
        return val;
    }
private:
    queue<int> que;
};

void producer(Queue *que) {
    for (int i = 1; i <= 10; i++) {
        que->put(i);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void consumer(Queue *que) {
    for (int i = 1; i <= 10; i++) {
        que->get();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

int main()
{
    Queue que;

    std::thread t1(producer, &que);
    std::thread t2(consumer, &que);

    t1.join();
    t2.join();

    return 0;
}

1、利用互斥锁和条件变量实现信号量

#include <iostream>
#include <mutex>
#include <condition_variable>
using namespace std;

class semaphore {
public:
    semaphore(int limit = 0) {
        limit_ = limit;
    }
    ~semaphore() = default;

    void wait() {
        unique_lock<mutex> lock(mtx_);
        cv_.wait(lock, [&]()->bool { return limit_ > 0; });
        limit_--;
    }

    void post() {
        unique_lock<mutex> lock(mtx_);
        limit_++;
        cv_.notify_all();
    }
private:
    int limit_;
    mutex mtx_;
    condition_variable cv_;
};

int main()
{

    return 0;
}

2、哲学家就餐问题

力扣1226题，这是一个经典的同步问题，常规思路就是让哲学家拿起左右两边的叉子，这个过程用信号量模拟，然后就餐：

在这里插入图片描述

代码如下：

class DiningPhilosophers {
public:
    const int n = 5;
    vector<unique_ptr<mutex>> mtxs;
    DiningPhilosophers() {
        for (int i = 0; i < n; i++) {
            mtxs.push_back(make_unique<mutex>());
        }
    }

    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {
		unique_lock<mutex> llock(*mtxs[philosopher]);
        unique_lock<mutex> rlock(*mtxs[(philosopher + n - 1) % n]);
        pickLeftFork();
        pickRightFork();
        eat();
        putLeftFork();
        putRightFork();
    }
};

但这显然会产生死锁，因为五个哲学家可能会同时拿起左边叉子，这时就会死锁。解决这个问题也简单，加把锁就行，把临界区锁住：

class DiningPhilosophers {
public:
    const int n = 5;
    mutex mtx;
    vector<unique_ptr<mutex>> mtxs;
    DiningPhilosophers() {
        for (int i = 0; i < n; i++) {
            mtxs.push_back(make_unique<mutex>());
        }
    }

    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {
        unique_lock<mutex> lock(mtx);
		unique_lock<mutex> llock(*mtxs[philosopher]);
        unique_lock<mutex> rlock(*mtxs[(philosopher + n - 1) % n]);
        pickLeftFork();
        pickRightFork();
        eat();
        putLeftFork();
        putRightFork();
    }
};

这样可以过，但是问题是同一时刻只能有一个哲学家进餐，显然，5把叉子可以让两个哲学家同时进餐。这个问题的关键在于5个哲学家同时拿起左边或者右边的叉子会导致死锁，那么我们可以规定拿起叉子的顺序，从而避免这种情况的发生。例如，规定偶数编号的哲学家先拿左边叉子，再拿右边叉子；奇数编号的哲学家先拿右边叉子，再拿左边叉子：

class DiningPhilosophers {
public:
    class semaphore {
    public:
        semaphore(int limit = 1) {
            limit_ = limit;
        }
        ~semaphore() = default;

        void wait() {
            unique_lock<mutex> lock(mtx_);
            cv_.wait(lock, [&]()->bool { return limit_ > 0; });
            limit_--;
        }

        void post() {
            unique_lock<mutex> lock(mtx_);
            limit_++;
            cv_.notify_all();
        }
    private:
        int limit_;
        mutex mtx_;
        condition_variable cv_;
    };
    static const int n = 5;
    semaphore s[n];
    DiningPhilosophers() {
        
    }

    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {
        if (philosopher % 2 == 0) {
            s[philosopher].wait();
            pickLeftFork();
            s[(philosopher + n - 1) % n].wait();
            pickRightFork();
        } else {
            s[(philosopher + n - 1) % n].wait();
            pickRightFork();
            s[philosopher].wait();
            pickLeftFork();
        }
        eat();
        putLeftFork();
        putRightFork();
        s[philosopher].post();
        s[(philosopher + n - 1) % n].post();
    }
};

四、再谈lock_guard和unique_lock

lock_guard不能用在函数参数传递或者返回过程中，只能用在简单的临界区代码段的互斥操作中，因为其拷贝构造函数和赋值运算符重载函数以经被删除，并且没有提供右值版本的实现。

参考资源

1、小林coding

标签
#c++ #开发语言
【施磊C++】智能指针
source7777的博客
10-03 1594
本文介绍了C++中智能指针的原理与实现，基于施磊老师的C++课程。});return 0;
施磊老师基于muduo网络库的集群聊天服务器(六)
weixin_65612492的博客
04-24 1458
每个表的主键, 联合主键, 无主键, 设置一定要正确, 什么允许重复, 什么不允许重复, 要搞明白, 不然业务 会出错或者不完整。：客户端只需按服务端定义的JSON协议收发数据（服务端要什么，客户端就发什么；服务端返回什么，客户端就解析什么），客户端在接收到这些信息后，会将其本地保存，方便用户随时查看，无需再次向服务器请求，从而提高整体交互效率。（仅需处理用户输入和服务器响应），无需像服务端那样处理多线程竞争、IO复用等复杂问题。：符合开闭原则，新增命令只需扩展映射表，无需修改主逻辑。
施磊C++课程学习路径，以及方法教程
最新发布
06-01
最强C++内容，C++学习路线。
【施磊】C++课程笔记目录
GeniusAng的博客
08-06 4041
【C++编程】施磊老师C++笔记目录
深入C++学习还必须掌握的一基础知识精讲
GeniusAng的博客
05-23 1442
施磊C++语言基础提高课程笔记，包括了new/delete；malloc/free；引用和指针；const，指计和引用的结合；函数重载，inline的数，参数带默认值的函数；函数模板等知识点
施磊老师 C++ 课程笔记--自己记录用
qq_35818865的博客
08-01 5941
施磊老师 C++课程笔记
C++基础笔记汇总——施磊课程
qq_58696030的博客
04-02 1795
3.从编译器角度理解C++代码的编译和链接原理。1.掌握进程虚拟空间地址区域划分。
施磊C++高级进阶课程 | 学习笔记 | 博客汇总
m0_74795952的博客
10-16 2629
剩余有关面试的等到明年投简历前学习。
施磊C++ | 进阶学习笔记 | 4.c++11内容汇总、多线程应用实践
m0_74795952的博客
10-13 1777
从多进程间通信的角度来看，竞态条件发生在两个或多个进程对共享的数据进行读或写的操作时，最终的结果取决于这些进程的执行顺序。在并发编程中，竞态条件通常指的是程序的执行结果依赖于线程执行的顺序。这样还是不完全安全，如果线程1在卖最后一张票，拿上锁，但还没有–的时候线程2进来了，他一看还有一张票，就等着锁资源，1卖完了最后一张，释放锁，2进来了卖的就是第0张票。原因是，对车票–操作不是一个线程安全的操作，每个线程减到一半可能时间片到了就去执行另外一个线程，导致一张票卖出去多次（出现了相同的数字的票）
施磊老师高级c++(二)
weixin_65612492的博客
03-19 1325
智能指针, 带引用计数交叉引用问题, 强弱指针, 自定义删除器
施磊C++ | 进阶学习笔记 | 2.智能指针
m0_74795952的博客
10-13 1519
学习C++的人，一直在接触裸指针，一边感受着它的强大，一边感受着它的坑爹。当然，坑不坑爹在于开发者，指针本身近乎完美，但奈何用的人比较猥琐，给自己埋下无数的坑，还哭喊着指针不好用，那么今天要介绍的智能指针可以释放大家在使用裸指针时的一些压力，当然智能指针无法替代裸指针的全部功能。忘记释放资源，导致资源泄露（常发生内存泄漏问题）同一资源释放多次，导致释放野指针，程序崩溃明明代码的后面写了释放资源的代码，但是由于程序逻辑满足条件，从中间return掉了，导致释放资源的代码未被执行到，懵。
施磊老师高级c++(四)
weixin_65612492的博客
03-22 1146
c++多线程, 互斥锁, 条件变量,无锁操作
施磊C++ | 项目实战 | 手写移植SGI STL二级空间配置器内存池 项目源码
m0_74795952的博客
10-25 906
手写移植内存池二级空间配置器内存池
施磊高级课程笔记
udahah的博客
04-10 367
使用不带计数的智能指针时，推荐使用unique_ptr,因为使用std：：move来把当前对象的资源传给下一个调用的对象，更形象。std：：forward ：将对象的值完美转化，也就是说输入左返回左，输入右返回右（因为编译器认为右值也是一种左值）c++对于对象构造的优化：用临时对象生成新对象的时候，临时对象就不产生了，直接构造新对象就行了。3.接收返回值是对象的函数调用的时候，优先按照初始化的方法接收，而不是按赋值的方法接收。2.函数返回对象的时候，应该优先返回一个临时对象，而不是一个定义过的对象。
施磊老师高级c++(五)
weixin_65612492的博客
03-23 1432
单例模式和工厂模式 笔记
【C++进阶笔记】智能指针（2）
m0_47023748的博客
12-08 612
C++学习笔记，智能指针部分
基于C++的可跨平台的线程间的同步通信（生产者消费者线程模型）
m0_51932378的博客
01-07 734
基于C++的可跨平台的线程操作，主要实现了线程间的同步通信（生产者消费者线程模型）。
MYSQL数据库连接池 | C++ | 项目实战
m0_74795952的博客
10-17 2369
本文主要介绍数据库连接池实现的相关细节
手写线程池
weixin_43364012的博客
08-28 340
操作系统上创建线程和销毁线程都是很"重"的操作，耗时较多，那么在服务执行的过程中如果业务量较大，实时的区创建线程、执行业务、业务完成后销毁线程会导致系统的实时性能降低。线程池的优势就是在服务进程启动之初就事先创建好线程池里面的线程，当业务到来时直接从线程池中获取一个空闲线程执行任务即可，任务执行完成之后也不要销毁线程，而是把线程归还到线程池中继续给后续的任务提供服务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值