linux_多任务互斥和同步（详解）

yz666^_^

已于 2024-05-09 10:03:15 修改

阅读量806

点赞数 21

分类专栏： linux 文章标签： c语言开发语言 linux 笔记

于 2024-05-09 09:36:29 首次发布

本文链接：https://blog.csdn.net/2403_83472896/article/details/138598337

版权

linux 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一多任务互斥和同步

1. 互斥和同步概述

前言

在多任务操作系统中，同时运行的多个任务可能都需要访问/使用同一种资源
多个任务之间有依赖关系，某个任务的运行依赖于另一个任务同步和互斥就是用于解决这两个问题的
互斥:
一个公用资源在同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源进程和线程同步和互斥的方法，主要有信号量和互斥锁死两种方式
同步
两个或两个以上的进程或线程在运行过程中协同步调，按预定的先后次序运行
同步就是在互斥的基础上有顺序

二互斥锁

2.1 互斥锁的概念

mutex是一种简单的加锁的方式来控制对资源的访问，mutex只有两种状态，即上锁（lock）和解锁（unlock）
如果mutex处于lock状态，则默认阻塞申请者
unlock操作应该由lock者进行

2.2 互斥锁的操作

2.2.1 初始化互斥锁

mutex用pthread_mutex_t数据类型表示，在使用互斥锁前，必须先对它进行初始化
静态分配的互斥锁：
pthread_mutex_t mutex = PTHREAD_MUTEX_INITALIZER;
动态分配互斥锁:
pthread_mutex_t mutex;
pthread_mutex_init(&mutex,NULL);
在所有使用过互斥锁的线程都不需要使用的时候,应调用销毁互斥锁
pthread_mutex_destroy销毁互斥锁

1 #include <pthread.h>
2 int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
3 功能: 初始化一个互斥锁
4 参数：
	mutex：指定的互斥锁
	mutexattr：互斥锁的属性，为NULL表示默认属性
5 返回值：
	成功返回0，失败返回非0

2.2.2 互斥锁上锁1

1. #include <pthread.h>
2. int pthread_mutex_lock(pthread_mutex t *mutex);
3. 功能：对互斥锁上锁，若已经上锁，则调用者已知阻塞到互斥锁解锁
4. 参数：mutex：互斥锁地址
5. 返回值： 成功返回0，失败返回非0

2.2.3 互斥锁上锁2

1. #include <pthread.h>
2. int pthread_mutex_trylock(pthread_mutex_t *mutex);
3. 功能：对互斥锁上锁,若已经上锁，则上锁失败，函数立即返回
4. 参数：mutex:互斥锁地址
5. 返回值：成功返回0，失败返回非0；

2.2.4 互斥锁解锁

1. #include <prhread.h>
2. int pthread_mutex_unlock(pthread_mutex_t *mutex);
3. 功能：对指定的互斥锁解锁
4. 参数：mutex：互斥锁地址
5. 返回值：成功返回0，失败返回非0；

2.2.5 销毁互斥锁

1. #include <prhread.h>
2. int pthread_mutex_destroy(pthread_mutex_t *mutex);
3. 功能：销毁指定的一个互斥锁
4. 参数：mutex：互斥锁地址
5. 返回值：成功返回0，失败返回非0；

2.3互斥锁案列（hank取钱）

2.3.1 不使用互斥锁的结果

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

int money = 10000;

void *thread_fun1(void *arg)
{
        int get,yu,shiji;
        get = 10000;

        printf("张三正在查询余额...\n");
        sleep(1);
        yu = money;

        printf("张三正在取钱...\n");
        sleep(1);
        if(get >yu){
                shiji = 0;

        }else{
                shiji = get;
                yu = yu - get;
                money = yu;
        }
        printf("张三想取%d元，实际取了%d元，余额为%d元\n",get,shiji,yu);
        pthread_exit(NULL);
}

void *thread_fun2(void *arg)
{
        int get,yu,shiji;
        get = 10000;

        printf("李四三正在查询余额...\n");
        sleep(1);
        yu = money;

        printf("李四正在取钱...\n");
        sleep(1);
        if(get >yu){
                shiji = 0;

        }else{
                shiji = get;
                yu = yu - get;
                money = yu;
        }
        printf("李四想取%d元，实际取了%d元，余额为%d元\n",get,shiji,yu);
        pthread_exit(NULL);
}

int main()
{

//      int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
        pthread_t thread1,thread2;
        if(pthread_create(&thread1,NULL,thread_fun1,NULL) == !0)
        {
                perror("fail to pthread_create");
                exit(1);
        }
        if(pthread_create(&thread2,NULL,thread_fun2,NULL) == !0)
        {
                perror("fail to pthread_create");
                exit(1);
        }
//      int pthread_join(pthread_t thread, void **retval);
        pthread_join(thread1,NULL);
        pthread_join(thread2,NULL);

        return 0;
}

执行结果
在这里插入图片描述

2.3.2 使用互斥锁的结果

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

//通过互斥锁解决线程间互斥问题

int money = 10000;
//第一步:创建互斥锁（由于两个线程操作同一个互斥锁，所以定义在全局更加方便）
pthread_mutex_t mymutex;
void *thread_fun1(void *arg)
{
        int get,yu,shiji;
        get = 10000;

        //第三步 对共享资源的操作进行上锁
        if(pthread_mutex_lock(&mymutex) == !0)
        {
                perror("fail to mutex_lock");
                exit(1);
        }

        printf("张三正在查询余额...\n");
        sleep(1);
        yu = money;

        printf("张三正在取钱...\n");
        sleep(1);
        if(get >yu){
                shiji = 0;

        }else{
                shiji = get;
                yu = yu - get;
                money = yu;
        }
        printf("张三想取%d元，实际取了%d元，余额为%d元\n",get,shiji,yu);

        //第四步：当共享资源的操作执行完毕后，对互斥锁执行解锁操作
        if(pthread_mutex_unlock(&mymutex) == !0)
        {
                perror("fail to unlock");
                exit(1);
        }


        pthread_exit(NULL);
}

void *thread_fun2(void *arg)
{
        int get,yu,shiji;
        get = 10000;

        //第三步 对共享资源的操作进行上锁
        if(pthread_mutex_lock(&mymutex) == !0)
        {
                perror("fail to mutex_lock");
                exit(1);
        }


        printf("李四三正在查询余额...\n");
        sleep(1);
        yu = money;

        printf("李四正在取钱...\n");
        sleep(1);
        if(get >yu){
                shiji = 0;

        }else{
                shiji = get;
                yu = yu - get;
                money = yu;
        }
        printf("李四想取%d元，实际取了%d元，余额为%d元\n",get,shiji,yu);

        //第四步：当共享资源的操作执行完毕后，对互斥锁执行解锁操作
        if(pthread_mutex_unlock(&mymutex) == !0)
        {
                perror("fail to unlock");
                exit(1);
        }

        pthread_exit(NULL);
}
int main()
{

//      int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
        // 第二步 初始化互斥锁
        if(pthread_mutex_init(&mymutex,NULL) == !0)
        {
                perror("fail to pthread_mutex_init");
                exit(1);
        }

        pthread_t thread1,thread2;
        if(pthread_create(&thread1,NULL,thread_fun1,NULL) == !0)
        {
                perror("fail to pthread_create");
                exit(1);
        }
        if(pthread_create(&thread2,NULL,thread_fun2,NULL) == !0)
        {
                perror("fail to pthread_create");
                exit(1);
        }
//      int pthread_join(pthread_t thread, void **retval);
        pthread_join(thread1,NULL);
        pthread_join(thread2,NULL);

//      第五步 当互斥锁执行完毕，销毁互斥锁
        if(pthread_mutex_destroy(&mymutex) == !0)
        {
                perror("fail to mutex_destroy");
                exit(1);
        }

        return 0;
}

执行结果

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=C%3A%5CUsers%5C17874%5CDesktop%5C%E6%89%A7%E8%A1%8C%E7%BB%93%E6%9E%9C%E5%9B%BE%E7%89%87%5Cbank_mu.png&pos_id=img-wR85vA3I-1715218289357
_join(thread2,NULL);

// 第五步当互斥锁执行完毕，销毁互斥锁
if(pthread_mutex_destroy(&mymutex) == !0)
{
perror(“fail to mutex_destroy”);
exit(1);
}

    return 0;

}

执行结果
![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/40a0a04753984ae693af3106a43807de.png#pic_center)

yz666^_^

关注

21
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
linux_多任务互斥和同步（详解）

在多任务操作系统中，同时运行的多个任务可能都需要访问/使用同一种资源多个任务之间有依赖关系，某个任务的运行依赖于另一个任务同步和互斥就是用于解决这两个问题的一个公用资源在同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源进程和线程同步和互斥的方法，主要有信号量和互斥锁死两种方式两个或两个以上的进程或线程在运行过程中协同步调，按预定的先后次序运行同步就是在互斥的基础上有顺序。
复制链接

扫一扫