【lesson55】线程同步

最新推荐文章于 2024-06-07 16:15:15 发布
最新推荐文章于 2024-06-07 16:15:15 发布
阅读量968 收藏 19
点赞数 33
分类专栏： linux 文章标签： Linux C++ 线程同步 性能优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67077469/article/details/136125763
版权

线程同步

同步：在保证数据安全的前提下，让线程能够按照某种特定的顺序访问临界资源，从而有效避免饥饿问题，叫做同步

例一：我们之前的抢票代码，一个线程把票全抢完了，它错了吗？没错！但是不合理。

例二：我们要去华为店里买华为Mate40，
第一天去华为专卖店，我们问店员有没有货，店员说没有，我们立马就转身离开。
第二天再去我们问店员有没有货，店员说没有，我们再次转身离开。
就这样连续去30天左右，店里终于有货了，我们买了就走。
上面这样有错吗？没错，但是不合理。

1.例子一频繁的申请到资源
2.例子二太过于浪费我自己和对方的资源（时间）
例子一和二都没有错但是不合理。

例子一造成别人的饥饿问题。

而线程同步主要就是为了解决，访问临界资源合理性的问题。
故事：
学校有一间自习室，每天早上8:00~晚上21:00开放，但是这间自习室只允许一个人进入，墙上有一把钥匙，钥匙需要大家抢夺，谁抢到钥匙谁就拥有自习室。

小明某一天早早的来到了自习室，拿了墙上的钥匙，就打开门，然后关上门把门反锁，再把钥匙放在兜里。
自习了几个小时小明准备去趟厕所，打开门发现人有点多，就把门反锁了然后把钥匙一起带走，上完厕所就再回来，自习室就还是属于自己的。
晚上要吃晚饭了，小明准备回去，一打开门发现门口人乌泱泱的，小明立马反悔，觉得还是再学一会吧。
又学了一会小明觉得该回去了，再次打开门，然后把钥匙挂墙上，可是刚挂上去小明又后悔了，而又因为小明里钥匙最近所以他又抢到了钥匙，然后回去再学了一会。

听完上面故事大家觉得合理吗？不合理，小明凭什么一直能抢到钥匙。
有人举报了小明，所以自习室管理员引入规则：
1.自习室外面的人必须排好队，不能乌泱泱的一群人挤在一起
2.人从自习室出来以后不能立马再次申请锁，得必须排到队伍的末尾。

按照一定顺序，进行临界资源的访问我们称之为线程同步。

如何保证顺序性？
条件变量
我们之前申请临界资源前---->都需要做临界资源是否存在的检测---->而检测的本质：也是访问临界资源！---->所以我们之前临界资源的检测也在加锁和解锁之间---->常规方式要检测条件就绪，注定了我们必须频繁申请和释放锁---->有没有办法让我们的线程检测到资源不就绪的时候。
1.不要让线程在频繁的自己检测了，我们等待资源就绪
2.当条件就绪的时候，通知对应的线程，让他来进行资源申请和访问！

之前买华为手机的例子，当店里没有货的时候，我们留下店员的联系方式或者留下自己的联系方式，让店员有货了在通知自己过去买手机。

条件变量：
当一个线程互斥地访问某个变量时，它可能发现在其它线程改变状态之前，它什么也做不了。
例如一个线程访问队列时，发现队列为空，它只能等待，只到其它线程将一个节点添加到队列中。这种情况就需要用到条件变量。

没加条件变量前的代码：

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>

#define TNUM 4

typedef void (*func)(std::string name);

struct ThreadData
{
public:
    ThreadData(std::string name, func func)
        : _name(name),
          _func(func)
    {
    }

public:
    std::string _name;
    func _func;
};

void fun1(std::string name)
{
    while (true)
    {
        std::cout << name << " running ------- a" << std::endl;
        sleep(1);
    }
}

void fun2(std::string name)
{
    while (true)
    {
        std::cout << name << " running ------- b" << std::endl;
        sleep(1);
    }
}

void fun3(std::string name)
{
    while (true)
    {
        std::cout << name << " running ------- c" << std::endl;
        sleep(1);
    }
}

void fun4(std::string name)
{
    while (true)
    {
        std::cout << name << " running ------- d" << std::endl;
        sleep(1);
    }
}

void *Entry(void *args)
{
    ThreadData *td = (ThreadData *)args;
    td->_func(td->_name);
    delete td;
}

int main()
{
    pthread_t tid[TNUM];
    func func[TNUM] = {fun1, fun2, fun3, fun4};

    for (int i = 0; i < TNUM; i++)
    {
        std::string name = "Thread";
        name += std::to_string(i + 1);
        ThreadData *td = new ThreadData(name, func[i]);
        pthread_create(tid + i, nullptr, Entry, (void *)td);
    }

    for (int i = 0; i < TNUM; i++)
    {
        pthread_join(tid[i], nullptr);
    }
    return 0;
}

运行结果：
在这里插入图片描述
我们看到线程是随机运行的，谁都有可能被CPU调度，那么我们如何让他顺序运行呢？
添加条件变量：
代码：

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>

#define TNUM 4

typedef void (*func)(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond);

struct ThreadData
{
public:
    ThreadData(std::string name, func func, pthread_mutex_t *mtx, pthread_cond_t *cond)
        : _name(name),
          _func(func),
          _mtx(mtx),
          _cond(cond)
    {
    }

public:
    std::string _name;
    func _func;
    pthread_mutex_t *_mtx;
    pthread_cond_t *_cond;
};

void fun1(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (true)
    {
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- a" << std::endl;
        //sleep(1);
    }
}

void fun2(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (true)
    {
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- b" << std::endl;
        //sleep(1);
    }
}

void fun3(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (true)
    {
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- c" << std::endl;
        //sleep(1);
    }
}

void fun4(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (true)
    {
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- d" << std::endl;
        //sleep(1);
    }
}

void *Entry(void *args)
{
    ThreadData *td = (ThreadData *)args;
    td->_func(td->_name,td->_mtx,td->_cond);
    delete td;

    return nullptr;
}

int main()
{
    pthread_mutex_t mtx;
    pthread_cond_t cond;

    pthread_mutex_init(&mtx, nullptr);
    pthread_cond_init(&cond, nullptr);

    pthread_t tid[TNUM];
    func func[TNUM] = {fun1, fun2, fun3, fun4};

    for (int i = 0; i < TNUM; i++)
    {
        std::string name = "Thread";
        name += std::to_string(i + 1);
        ThreadData *td = new ThreadData(name, func[i], &mtx, &cond);
        pthread_create(tid + i, nullptr, Entry, (void *)td);
    }

    while(true)
    {
        std::cout << "Wake up thread run code ......." << std::endl;
        pthread_cond_signal(&cond);
        sleep(1);
    }

    for (int i = 0; i < TNUM; i++)
    {
        pthread_join(tid[i], nullptr);
    }

    pthread_mutex_destroy(&mtx);
    pthread_cond_destroy(&cond);
    return 0;
}

运行结果：
在这里插入图片描述
我们看到线程变的井然有序，一个一个的执行。
在这里插入图片描述
pthread_cond_signal是一个一个的唤醒线程，我们还可以用pthread_cond_broadcast一批一批的唤醒。
修改代码片段
在这里插入图片描述
运行代码：
在这里插入图片描述
如果我们想让线程运行10次就退出，那么代码该如何更改呢？
我们在全局定义一个bool类型的quit。然后每个线程用quit判断退出条件即可。
代码：

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>

#define TNUM 4

bool quit = false;

typedef void (*func)(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond);

struct ThreadData
{
public:
    ThreadData(std::string name, func func, pthread_mutex_t *mtx, pthread_cond_t *cond)
        : _name(name),
          _func(func),
          _mtx(mtx),
          _cond(cond)
    {
    }

public:
    std::string _name;
    func _func;
    pthread_mutex_t *_mtx;
    pthread_cond_t *_cond;
};

void fun1(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (!quit)
    {
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- a" << std::endl;
        //sleep(1);
    }
}

void fun2(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (!quit)
    {
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- b" << std::endl;
        //sleep(1);
    }
}

void fun3(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (!quit)
    {
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- c" << std::endl;
        //sleep(1);
    }
}

void fun4(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (!quit)
    {
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- d" << std::endl;
        //sleep(1);
    }
}

void *Entry(void *args)
{
    ThreadData *td = (ThreadData *)args;
    td->_func(td->_name,td->_mtx,td->_cond);
    delete td;

    return nullptr;
}

int main()
{
    pthread_mutex_t mtx;
    pthread_cond_t cond;

    pthread_mutex_init(&mtx, nullptr);
    pthread_cond_init(&cond, nullptr);

    pthread_t tid[TNUM];
    func func[TNUM] = {fun1, fun2, fun3, fun4};

    for (int i = 0; i < TNUM; i++)
    {
        std::string name = "Thread";
        name += std::to_string(i + 1);
        ThreadData *td = new ThreadData(name, func[i], &mtx, &cond);
        pthread_create(tid + i, nullptr, Entry, (void *)td);
    }

    int cnt = 10;
    while(cnt)
    {
        std::cout << std::endl;
        std::cout << "Wake up thread run code ......." <<  cnt-- << std::endl;
        //pthread_cond_signal(&cond);
        pthread_cond_broadcast(&cond);
        sleep(1);
    }

    quit = true;

    for (int i = 0; i < TNUM; i++)
    {
        pthread_join(tid[i], nullptr);
    }

    pthread_mutex_destroy(&mtx);
    pthread_cond_destroy(&cond);
    return 0;
}

运行结果：
在这里插入图片描述
我们看到这最后卡住了是为什么呢？因为我们虽然是quit但是，所有线程还在条件变量上等待呢，而条件变量是在加锁和解锁之间的，我们虽然退出了但是锁并没有处理好。
所以我们在每个线程都要加上加锁解锁的逻辑。
代码：

#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>

#define TNUM 4

bool quit = false;

typedef void (*func)(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond);

struct ThreadData
{
public:
    ThreadData(std::string name, func func, pthread_mutex_t *mtx, pthread_cond_t *cond)
        : _name(name),
          _func(func),
          _mtx(mtx),
          _cond(cond)
    {
    }

public:
    std::string _name;
    func _func;
    pthread_mutex_t *_mtx;
    pthread_cond_t *_cond;
};

void fun1(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (!quit)
    {
        pthread_mutex_lock(mtx);
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- a" << std::endl;
        pthread_mutex_unlock(mtx);
        //sleep(1);
    }
}

void fun2(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (!quit)
    {
        pthread_mutex_lock(mtx);
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- b" << std::endl;
        pthread_mutex_unlock(mtx);
        //sleep(1);
    }
}

void fun3(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (!quit)
    {
        pthread_mutex_lock(mtx);
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- c" << std::endl;
        pthread_mutex_unlock(mtx);
        //sleep(1);
    }
}

void fun4(std::string name,pthread_mutex_t *mtx, pthread_cond_t *cond)
{
    while (!quit)
    {
        pthread_mutex_lock(mtx);
        pthread_cond_wait(cond,mtx);
        std::cout << name << " running ------- d" << std::endl;
        pthread_mutex_unlock(mtx);
        //sleep(1);
    }
}

void *Entry(void *args)
{
    ThreadData *td = (ThreadData *)args;
    td->_func(td->_name,td->_mtx,td->_cond);
    delete td;

    return nullptr;
}

int main()
{
    pthread_mutex_t mtx;
    pthread_cond_t cond;

    pthread_mutex_init(&mtx, nullptr);
    pthread_cond_init(&cond, nullptr);

    pthread_t tid[TNUM];
    func func[TNUM] = {fun1, fun2, fun3, fun4};

    for (int i = 0; i < TNUM; i++)
    {
        std::string name = "Thread";
        name += std::to_string(i + 1);
        ThreadData *td = new ThreadData(name, func[i], &mtx, &cond);
        pthread_create(tid + i, nullptr, Entry, (void *)td);
    }

    int cnt = 10;
    while(cnt)
    {
        std::cout << std::endl;
        std::cout << "Wake up thread run code ......." <<  cnt-- << std::endl;
        //pthread_cond_signal(&cond);
        pthread_cond_broadcast(&cond);
        sleep(1);
    }
    
    quit = true;
   

    for (int i = 0; i < TNUM; i++)
    {
        pthread_join(tid[i], nullptr);
    }

    pthread_mutex_destroy(&mtx);
    pthread_cond_destroy(&cond);
    return 0;
}

运行结果：
在这里插入图片描述
我们看到这最后卡住了是为什么呢？因为我们虽然是quit但是，所有线程还在条件变量上等待呢，所以我们需要在退出后再进行一次pthread_cond_broadcast（）；
在这里插入图片描述
运行结果：
在这里插入图片描述

(unstoppable)
关注
  • 33
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized同步的实现——多线程购票
footprint01的博客
09-03 1051
同步的由来 当两个或两个以上的线程需要共享资源，必须使用某种方法来确定资源在某一时刻仅被一个线程占用，达到此目的的过程叫做同步。（synchronized） 同步的实现 方法级同步（method-level synchronized） synchronized void method( ) { //同步的方法 } 对象级同步（ block-level syn...
第三周 IO流与线程
qq_45240350的博客
07-19 356
IO流 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pFCSLQXO-1595163909897)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1595162301195.png)] 流概述 IO（Input/Ouput），Java中将不同的输入输出源抽象表示为流；流是一种从输入源到接收地的抽像概念; 输入输出源 文件 网络 内存 根据流的不同状态划分，将流做以下区分： 从流向考虑(站在程序角度考
多线程基础学习
weixin_44932316的博客
10-18 151
多线程 线程简介 程序：指令和数据的有序集合，只是个静态的概念。 进程是执行程序的一次执行过程，作为一个动态概念，是系统资源分配的单位。 一个进程可包含多个线程且最少有一个线程 真正的多线程是指有多个cpu即多核，如服务器，如果是模拟出来的多线程，本质上还是处于同一个cpu，同一时间单位只能执行一项代码任务，不能同时进行，只是切换的快产生的错觉。 线程是独立的执行路径。 在进程中开辟多线程，线程运行由调度器安排调度，不能人为干预。 资源抢夺问题，需加入并发控制。 继承Thre
JavaSE-20.2.3【线程同步：线程安全的类、Lock锁】
yubaby
06-10 95
1 package day11.lesson2; 2 3 import java.util.*; 4 import java.util.concurrent.locks.Lock; 5 import java.util.concurrent.locks.ReentrantLock; 6 7 /* 8 2.5 线程安全的类 9 10 StringBuffer 11...
有关多线程(同步锁，递归锁，同步对象，信号量)
weixin_30379531的博客
08-26 58
上面一个随笔已经简单介绍了多线程，比如下面在举个简单的例子： 1 #!/usr/bin/env python 2 #-*-coding:utf-8 -*- 3 4 import threading 5 import time 6 7 def add(): 8 sum = 0 9 10 for i in range(1000000)...
python 34 进程、线程、协程
qq_30346413的博客
05-26 526
一、进程和线程 1、进程 假如有两个程序A和B，程序A在执行到一半的过程中，需要读取大量的数据输入（I/O操作）， 而此时CPU只能静静地等待任务A读取完数据才能继续执行，这样就白白浪费了CPU资源。 是不是在程序A读取数据的过程中，让程序B去执行，当程序A读取完数据之后，让 程序B暂停，然后让程序A继续执行？ 当然没问题，但这里有一个关键词：切换 既然是切换，那么这就涉及到了状态的保存，状态的恢复，加上程序A与程序B所需要的系统资 源（内存，硬盘，...
JavaSE-20.2.2【线程同步：同步代码块、同步方法解决数据安全问题(卖票案例问题解决)】...
yubaby
06-10 85
1 package day11.lesson2; 2 3 /* 4 2.3 同步代码块解决数据安全问题(卖票案例问题解决) 5 6 卖票案例为啥会出现问题？(多线程程序出现安全问题的标准条件) 7 是多线程环境 8 有共享数据 9 有多条语句操作共享数据 10 11 如何解决多线程安全问题呢? 12 ...
JavaSE-20.2.1【线程同步：案例-卖票、卖票案例存在的问题】
yubaby
06-10 120
1 package day11.lesson2; 2 3 /* 4 2 线程同步 5 6 2.1 案例-卖票 7 8 需求 9 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票 10 11 步骤 12 定义一个类SellTicket实现Runnable接口，里面定义一个成员...
Lesson41_SpringBoot
weixin_44120423的博客
06-01 1868
SpringBoot
Lesson16线程同步与异步套接字编程
05-10
线程同步与异步套接字编程 线程同步与异步套接字编程
visual c++ MFC之Lesson16线程同步与异步套接字编程
12-06
visual c++ MFC之Lesson16线程同步与异步套接字编程
lesson55-VAE实战.zip
08-24
Pytorch 实战
Lesson07-多线程.pdf
08-05
多线程 在计算机编程中，一个基本的概念就是同时对多个任务加以控制。许多程序设计问题都要求程序能够停下手头的工作，改为处理其他一些问题，再返回主进程。可以通过多种途径达到这个目的。最开始的时候，那些掌握...
Unit3Lesson16Atthesupermarket同步练习.docx
01-24
Unit3Lesson16Atthesupermarket同步练习.docx
MySQL之查询性能优化(九)
Cover_sky的博客
06-07 645
有时，MySQL无法将限制条件从外层"下推"到内层，这使得原本能够限制部分返回结果的条件无法应用到内层查询的优化上。如果希望UNION的各个子句能够根据LIMIT只取部分结果集，或者希望能够先排好序再合并结果集的话，就需要在UNION的各个子句中分别使用这些子句。这条查询将会把actor中的200条记录和customer表中的599条记录存放在一个临时表中，然后再从临时表中取出前20条。
MySQL之查询性能优化(四)
Cover_sky的博客
06-04 1724
一般来说，不需要去理解MySQL通信协议的内部实现细节，只需要大致理解通信协议是如何工作的。MySQL客户端和服务器之间的通信协议是"半双工"的，这意味着，在任何一个时刻，要么是由服务器向客户端发送数据，要么是由客户端向服务器发送数据，这两个动作不能同时发生。所以，我们也无法也无须将一个消息切成小块独立来发送。这种协议让MySQL通信简单快速，但是也从很多地方限制了MySQL.一个明显的限制是，这意味着没法进行流量控制。一旦一端开始发送消息，另一端要接收完整个消息才能响应它。
PostgreSQL17性能优化（2）允许将相关的IN子查询转换为连接
m0_61738548的博客
06-07 338
本文将介绍PostgreSQL 17服务端优化器允许将相关的IN子查询转换为连接。
基于Ascend C的FlashAttention算子性能优化最佳实践
最新发布
m0_71340392的博客
06-07 450
针对FlashAttention反向融合算子的性能优化方案展开介绍，并通过优化实现了典型场景4倍左右的性能提升，希望对开发者优化此类基于Ascend C开发的融合算子带来启发。
对lesson数据进行预处理
06-06
对于lesson数据进行预处理的目的是为了优化数据的质量、可用性和可靠性，以便更好地支持后续的数据分析工作。下面我将从数据清洗、数据规范化、数据转换、数据集成四个方面说明如何对lesson数据进行预处理。 首先是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值