互斥锁，条件变量，信号量的三个小demo

最新推荐文章于 2024-11-04 21:10:47 发布
最新推荐文章于 2024-11-04 21:10:47 发布
阅读量124 收藏
点赞数
文章标签： linux c语言 c++ 开发语言 服务器 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52625576/article/details/132841680
版权

仨demo

一、 一个线程读文件，另一个线程将读取的内容输出到终端

1.1 要求

  • 创建两个线程，
  • 其中一个线程读取文件中的数据，
  • 另外一个线程将读取到的内容打印到终端上，
  • 类似实现cat一个文件。
    • cat数据完毕后，要结束两个线程。
  • 提示：先读数据，读到数据后将数据打印到终端上。

1.2 代码实现

/*
创建两个线程，
其中一个线程读取文件中的数据，
另外一个线程将读取到的内容打印到终端上，
类似实现cat一个文件。
    cat数据完毕后，要结束两个线程。
提示：先读数据，读到数据后将数据打印到终端上。
*/
#include <my_head.h>

//  用于暂存的存储
char buff[16];
//  用于接收返回值，读取的字节数
ssize_t res;

//  创建互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//  创建条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int flag = 0;

//  读文件
void *read_file(void *);

//  写到终端
void *write_out(void *);

int main(int argc, const char *argv[])
{
    //  以只读的方式打开 “abc.c” 文件
    //  可以换，也可以换成外部参数，按自己需求
    int fd = open("abc.c", O_RDONLY);

    //  创建线程1，用于读文件，并将文件描述符传过去
    pthread_t tid1;
    if (pthread_create(&tid1, NULL, read_file, &fd) != 0)
    {
        fprintf(stderr, "pthread_create tid1 error\n");
        return -1;
    }

    //  创建线程2，用于写到终端
    pthread_t tid2;
    if (pthread_create(&tid2, NULL, write_out, NULL) != 0)
    {
        fprintf(stderr, "pthread_create tid2 error\n");
        return -1;
    }

    //  等待两个线程结束
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    return 0;
}

//  读文件
void *read_file(void *arg)
{
    //  接收传进来的文件描述符
    int fd = *(int *)arg;
    while (1)
    {
        //  上锁
        pthread_mutex_lock(&mutex);
        //  若标志不是0，说明不该当前线程执行，所以要沉睡
        if (0 != flag)
        {
            //  不是当前线程的执行时机
            pthread_cond_wait(&cond, &mutex);
        }
        //  清空暂存数据的存储空间
        bzero(buff, sizeof(buff));
        //  读取文件中的数据放到暂存空间
        res = read(fd, buff, sizeof(buff));
        //  读取错误则报错，并退出线程
        if (0 > res)
        {
            ERR_MSG("read error");
            return NULL;
        }
        //  读到最后啥都没读到，那就尝试唤醒另一个，然后解锁结束循环，之后终止线程
        else if (0 == res)
        {
            //  尝试唤醒另一个线程
            pthread_cond_signal(&cond);
            //  解锁
            pthread_mutex_unlock(&mutex);
            break;
        }
        //  修改标志
        flag = 1;
        //  当前部分执行完了，该唤醒另一个了
        pthread_cond_signal(&cond);
        //  解锁
        pthread_mutex_unlock(&mutex);
    }
    //  终止当前线程
    pthread_exit(NULL);
}

//  写到终端
void *write_out(void *arg)
{
    while (1)
    {
        //  上锁
        pthread_mutex_lock(&mutex);

        //  看是否属于当前该执行的时机
        if (1 != flag)
        {
            //  不属于当前该执行的时机，那就睡过去吧
            pthread_cond_wait(&cond, &mutex);
        }
        //  没东西可以输出，尝试唤醒另一个，并解锁，然后终止当前线程
        if (0 == res)
        {
            //  尝试唤醒另一个线程
            pthread_cond_signal(&cond);
            //  解锁
            pthread_mutex_unlock(&mutex);
            break;
        }
        //  向终端输出
        write(1, buff, res);
        //  修改标志
        flag = 0;
        //  当前任务执行完了，该让另一个线程启动了
        pthread_cond_signal(&cond);
        //  解锁
        pthread_mutex_unlock(&mutex);
    }
    //  终止当前线程
    pthread_exit(NULL);
}

二、 三个线程打印ABC，每个线程打一个字符，且顺序不变

2.1 要求

  • 有三个线程，ID号分别为ABC，且每个线程中都在循环打印自己的ID。
    • 要求打印的结果为ABC。

2.2 代码实现

/*
有三个线程，ID号分别为ABC，且每个线程中都在循环打印自己的ID。
    要求打印的结果为ABC。
*/
#include <my_head.h>

//  互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//  条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
//  标志:0为A，1位B，2为C
int flag = 0;

//  线程A
void *print_A(void *);
//  线程B
void *print_B(void *);
//  线程C
void *print_C(void *);

int main(int argc, const char *argv[])
{
    //  创建三个线程
    pthread_t tid1;
    pthread_t tid2;
    pthread_t tid3;
    if (pthread_create(&tid1, NULL, print_A, NULL) != 0)
    {
        fprintf(stderr, "pthread_create A error\n");
        return -1;
    }
    if (pthread_create(&tid2, NULL, print_B, NULL) != 0)
    {
        fprintf(stderr, "pthread_create A error\n");
        return -1;
    }
    if (pthread_create(&tid3, NULL, print_C, NULL) != 0)
    {
        fprintf(stderr, "pthread_create A error\n");
        return -1;
    }

    //  等待三个线程结束
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    pthread_join(tid3, NULL);
    return 0;
}

//  线程A
void *print_A(void *arg)
{
    while (1)
    {
        //  上锁
        pthread_mutex_lock(&mutex);
        //  判断是否是输出A的时机
        if (flag == 0)
        {
            //  是输出A的时机，输出A，然后将标志改为1准备输出B，之后唤醒其他线程
            printf("A");
            flag = 1;
            //  唤醒其他线程
            pthread_cond_signal(&cond);
        }
        //  不是输出A的时机
        else
        {
            //  直接进入休眠
            pthread_cond_wait(&cond, &mutex);
        }

        //  解锁
        pthread_mutex_unlock(&mutex);
    }
    //  结束当前线程(虽然死循环，不会结束线程，但是为了规范点，还是写上)
    pthread_exit(NULL);
}
//  线程B
void *print_B(void *arg)
{
    while (1)
    {
        //  上锁
        pthread_mutex_lock(&mutex);
        //  判断是否是输出B的时机
        if (flag == 1)
        {
            //  是输出B的时机，输出B，然后将标志改为2准备输出C，之后唤醒其他线程
            printf("B");
            flag = 2;
            //  唤醒其他线程
            pthread_cond_signal(&cond);
        }
        //  不是输出B的时机
        else
        {
            //  直接进入休眠
            pthread_cond_wait(&cond, &mutex);
        }

        //  解锁
        pthread_mutex_unlock(&mutex);
    }
    //  结束当前线程(虽然死循环，不会结束线程，但是为了规范点，还是写上)
    pthread_exit(NULL);
}
//  线程C
void *print_C(void *arg)
{
    while (1)
    {
        //  上锁
        pthread_mutex_lock(&mutex);
        //  判断是否是输出C的时机
        if (flag == 2)
        {
            //  是输出C的时机，输出C，然后将标志改为0准备输出A，之后唤醒其他线程
            printf("C\n");
            flag = 0;
            //  唤醒其他线程
            pthread_cond_signal(&cond);
        }
        //  不是输出C的时机
        else
        {
            //  直接进入休眠
            pthread_cond_wait(&cond, &mutex);
        }
        //  解锁
        pthread_mutex_unlock(&mutex);
    }
    //  结束当前线程(虽然死循环，不会结束线程，但是为了规范点，还是写上)
    pthread_exit(NULL);
}

三、 用信号量实现一个线程对字符串逆置，另一线程对字符串输出

3.1 要求

  • 要求定义一个全局变量 char buf[] = “1234567”，创建两个线程，不考虑退出条件。
  • A线程循环打印buf字符串，
  • B线程循环倒置buf字符串，
  • 即buf中本来存储1234567，倒置后buf中存储7654321.
    • B线程中不打印！！
    • 倒置不允许使用辅助数组。
    • 要求A线程打印出来的结果只能为 1234567 或者 7654321
    • 不允许出现7634521 7234567
    • 不允许使用sleep函数
    • 用信号量的方式实现上述代码顺序执行，不允许使用flag;

3.2 代码实现

/*
要求定义一个全局变量 char buf[] = "1234567"，创建两个线程，不考虑退出条件。
A线程循环打印buf字符串，
B线程循环倒置buf字符串，
即buf中本来存储1234567，倒置后buf中存储7654321.
    B线程中不打印！！
    倒置不允许使用辅助数组。
    要求A线程打印出来的结果只能为 1234567  或者  7654321
    不允许出现7634521  7234567
    不允许使用sleep函数
    分析出现错误的原因。
    用信号量的方式实现上述代码顺序执行，不允许使用flag;
*/
#include <my_head.h>

//  俩信号量
sem_t sem1;
sem_t sem2;

//  数据
char buff[] = "1234567";

//  输出线程
void *print_str(void *arg);
//  逆置线程
void *turn_str(void *arg);

int main(int argc, const char *argv[])
{
    /*
    这俩信号量第一个初始化为1，第二个初始化为0
    能够保证是先进行线程1，即输出线程，后进行线程2，即逆置线程
    而在输出线程中
        先获取信号量1，操作执行完再释放信号量2，(注意是释放信号量2)
        因为信号量1的初始值为1，所以只会执行一次线程1
        信号量2的初始值为0，在线程1中释放信号量2后变成了1，这样可以执行一次线程2
    在逆置线程中也是同理
        先获取线程1中释放的信号量2，操作执行完再释放信号量1
        获取线程1释放的信号量2，而信号量2只够线程2执行一次，
        在线程2操作执行完后释放信号量1，可以让线程1能够再次执行1次，
        如此往复
    */
    //  信号量初始化为1，也就是在这个信号量下初始只能走一个线程
    if (sem_init(&sem1, 0, 1) < 0)
    {
        ERR_MSG("sem_init");
        return -1;
    }
    //  信号量初始化为0，也就是初始的时候没有可用的信号量
    if (sem_init(&sem2, 0, 0) < 0)
    {
        ERR_MSG("sem_init");
        return -1;
    }

    //  创建俩线程
    pthread_t tid1;
    pthread_t tid2;
    if (pthread_create(&tid1, NULL, print_str, NULL) != 0)
    {
        fprintf(stderr, "pthread_create tid1 error\n");
        return -1;
    }
    if (pthread_create(&tid2, NULL, turn_str, NULL) != 0)
    {
        fprintf(stderr, "pthread_create tid2 error\n");
        return -1;
    }

    //  等待两个线程结束
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

//  输出线程
void *print_str(void *arg)
{
    while (1)
    {
        //  P操作
        if (sem_wait(&sem1) < 0)
        {
            ERR_MSG("print_str sem_wait");
            return NULL;
        }
        //  要执行的操作
        printf("%s\n", buff);

        //  V操作
        if (sem_post(&sem2) < 0)
        {
            ERR_MSG("print_str sem_post");
            return NULL;
        }
    }
    //  结束当前线程(虽然死循环，不会结束线程，但是为了规范点，还是写上)
    pthread_exit(NULL);
}
//  逆置线程
void *turn_str(void *arg)
{
    int len = strlen(buff);

    while (1)
    {
        //  P操作
        if (sem_wait(&sem2) < 0)
        {
            ERR_MSG("print_str sem_wait");
            return NULL;
        }

        //  要执行的操作
        char *s = buff, *s1 = buff + len - 1;
        //  翻转
        while (s < s1)
        {
            (*s) ^= (*s1);
            (*s1) ^= (*s);
            (*s) ^= (*s1);
            s++;
            s1--;
        }

        //  V操作
        if (sem_post(&sem1) < 0)
        {
            ERR_MSG("print_str sem_post");
            return NULL;
        }
    }
    //  结束当前线程(虽然死循环，不会结束线程，但是为了规范点，还是写上)
    pthread_exit(NULL);
}
zhk___
关注
java互斥锁和信号量例子
wjg220000的博客
04-19 329
java 互斥锁 信号量 区别
线程互斥量、线程信号量 编程案例
m0_56051805的博客
07-20 317
线程互斥量、线程信号量 编程案例
多线程的同步与互斥（互斥锁、条件变量、读写锁、自旋锁、信号量）
热门推荐
青萍之末的博客
10-06 8万+
一、同步与互斥的概念   现代操作系统基本都是多任务操作系统，即同时有大量可调度实体在运行。在多任务操作系统中，同时运行的多个任务可能： 都需要访问/使用同一种资源； 多个任务之间有依赖关系，某个任务的运行依赖于另一个任务。 【同步】：   是指散步在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：两个或两个以...
Qt 线程同步机制 互斥锁 信号量 条件变量 读写锁
weixin_50873490的博客
07-09 1616
上述展示了Qt多线程编程的基本知识，与C语言、C++等语言线程大体上一致。线程间的同步和互斥涉及到的知识点大体不差。Qt还可以通过信号和槽连接，在不同线程之间进行通信和同步。Qt多线程编程更需要关注的点是线程的生命周期以及如何更加优雅的退出线程。Qt除了线程还提供了一些模块、线程池等功能和机制来实现并发执行。37-Qmutex-QSempahor · jbjnb/Qt demo - 码云 - 开源中国 (gitee.com)
​生产者消费者问题（互斥锁和条件变量的结合）
weixin_67596609的博客
09-19 1662
本篇文章对生产者消费者（模型）问题进行了详解。其中给出了基于阻塞队列的生产者消费者模型demo代码和对涉及到的条件变量与互斥锁的操作也进行了详细解释。解释了条件变量等待时，为什么还需要一把锁的问题。对生产者消费者（模型）问题进行总结，且解释了生产者消费者（模型）问题效率提升的所在。希望本篇文章会对你有所帮助。
linux 线程同步 互斥锁、条件变量、读写锁、自旋锁、信号量
Shanks
02-14 221
以下内容转载自https://www.toutiao.com/i6850002300325347843/ linux技术栈2020-07-16 17:07:24 一、互斥锁（同步）   在多任务操作系统中，同时运行的多个任务可能都需要使用同一种资源。这个过程有点类似于，公司部门里，我在使用着打印机打印东西的同时（还没有打印完），别人刚好也在此刻使用打印机打印东西，如果不做任何处理的话，打印出来的东西肯定是错乱的。   在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控.
详解linux多线程——互斥锁、条件变量、读写锁、自旋锁、信号量
Linuxhus的博客
11-03 344
如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。3. 非繁忙等待：如果一个线程已经锁定了一个互斥量，第二个线程又试图去锁定这个互斥量，则第二个线程将被挂起（不占用任何cpu资源），直到第一个线程解除对这个互斥量的锁定为止，第二个线程则被唤醒并继续执行，同时锁定这个互斥量。在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。
015线程同步_互斥锁_读写锁_条件变量_信号量
m0_73604721的博客
11-25 310
线程同步_互斥锁_读写锁_条件变量_信号量
C/C++：互斥锁和条件变量
无聊科技
08-24 7770
       互斥锁、条件变量和信号量是实现线程间同步的三种方式。在多线程程序访问临界资源时，可以对各个线程进行访问限制，每次只允许一个线程访问临界资源。条件变量相当于是互斥锁的一种补充，是线程中的东西，就是等待某一条件的发生，和信号一样。占有临界资源的线程在执行完对于资源的操作后，会发出“信号”，然后其它未占有资源的线程在感知到“信号”后就会抢占资源。 互斥锁的使用 需要的头文件：pthre...
多线程互斥锁和条件变量demo
06-13
在编程领域，多线程是实现并发执行任务的重要方式，特别是在多核处理器系统中，它能有效利用...对于初学者来说，分析并实践“多线程互斥锁和条件变量demo”是一个很好的起点，它可以帮助你更好地理解和运用这些工具。
互斥锁与事件锁
02-26
在多线程编程中，互斥锁（Mutex）和事件锁（Event）是两种常见的同步机制，用于确保多个线程安全地访问共享资源。本文将深入探讨这两种锁的工作原理、使用场景及其优缺点。 首先，互斥锁是线程同步的基础工具之一。...
Linux/Unix echo命令
Oo_Amy_oO的博客
11-04 750
echo是 Linux 和 Unix 系统中一个非常基本且常用的命令行工具，用于在终端或文件中显示文本。以下是一些echo在终端显示 “Hello, World!echo $PATH显示环境变量PATH的值。将 “New content” 写入file.txt，如果文件不存在则创建它。将 “Additional content” 追加到file.txt文件的末尾。使用-e选项来解释转义序列（如\n表示换行）。使用-n选项来防止echo命令在输出后添加换行符。echo $?显示上一个命令的退出状态。$(
第三章.Linux文件管理和IO重定向
Raymond的博客
10-30 89
Linux的文件系统分层结构：FHS Filesystem Hierarchy Standard参考文档：http://www.pathname.com/fhs/ 1.3 应用程序的组成部分 1.4 CentOS 7 以后版本目录结构变化 /bin 和 /usr/bin /sbin 和 /usr/sbin /lib 和/usr/lib /lib64 和 /usr/lib64 范例： 1.5 Linux下的文件类型 - 普通文件 d 目录文件directory b 块设备block c 字符设备cha
[linux 驱动]PWM子系统详解
weixin_49406449的博客
11-04 469
搜索“rockchip,rk3328-pwm”，发现在./drivers/pwm/pwm-rockchip.c 出现，所以 pwm6 的驱动是pwm-rockchip。任何 PWM 设备实例都可以被注册到 pwm_class 下，用户空间应用可以通过 /sys/class/pwm 访问这些设备，实现对 PWM 功能的控制。struct pwm_device *pwm: 这是指向 PWM 设备结构体的指针，该结构体是在调用 pwm_request 函数时获取的。这是指向该控制器的 PWM 通道的数组或链表。
Linux 之 信号概念、进程、进程间通信、线程、线程同步
挥剑决浮云的博客
11-01 667
如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。事实上，子进程是父进程的一个副本，譬如子进程拷贝了父进程的数据段、堆、栈以及继承了父进程打开的文件描述符，父进程与子进程并不共享这些存储空间，这是子进程对父进程相应部分存储空间的完全复制，执行fork()之后，每个进程均可修改各自的栈数据以及堆段中的变量，而并不影响另一个进程。是一族函数，而不是一个单独的函数。
Linux 基础IO
Emilia_is_angel的博客
11-02 801
对Linux的文件系统和IO接口进行了简单的介绍
linux-下载抖音作品
qq_64171874的博客
11-04 187
在linux中批量下载抖音作品。
【Linux】文件系统
weixin_74792326的博客
10-30 802
删一个文件的时候，拿到文件编号，到inode Bitmap里找到文件的inode编号，看它的位图是1说明他是有效的，然后再去inode Table读取它的属性，获得对应的块的块号，在Block Bitmap中将所有块号全部清零，然后再去inode Bitmap里将对应的清0，就完成了文件的删除。每一个inode都有自己的inode编号（inode的设置，是以分区为单位的，不能跨分区） inode表示文件的所有属性，文件名，并不属于inode内的属性。那么，我们怎么知道一个文件的inode编号？
Linux之初体验
最新发布
枫原万叶的博客
11-04 507
Linux之初体验
Linux多线程同步：互斥锁、条件变量与信号量解析
"这篇文档介绍了Linux系统中用于多线程同步的三种机制——互斥锁、条件变量和信号量，重点讲述了互斥锁的概念、使用方法以及注意事项，以确保对共享资源的正确访问和管理。" 在多线程编程中，尤其是在Linux环境下，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhk___

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值