互斥锁概念简单说明和举例

本文内容主要来自博文:Linux系统编程——线程同步与互斥:互斥锁

同时补充以下博文说明:

  [1]  Linux线程-互斥锁pthread_mutex_t

  [2]  POSIX 互斥锁: pthread_mutex_t

为什么需要互斥锁?

在多任务操作系统中,同时运行的多个任务可能都需要使用同一种资源。这个过程有点类似于,公司部门里,我在使用着打印机打印东西的同时(还没有打印完),别人刚好也在此刻使用打印机打印东西,如果不做任何处理的话,打印出来的东西肯定是错乱的。

下面我们用程序模拟一下这个过程,线程一需要打印“ hello ”,线程二需要打印“ world ”,不加任何处理的话,打印出来的内容会错乱:

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

    // 打印机
    void printer(char *str)
    {
        while(*str!=‘\0‘)
        {
            putchar(*str);
            fflush(stdout);
            str++;
            sleep(1);
        }
        printf("\n");
    }  

    // 线程一
    void *thread_fun_1(void *arg)
    {
        char *str = "hello";
        printer(str); //打印
    }  

    // 线程二
    void *thread_fun_2(void *arg)
    {
        char *str = "world";
        printer(str); //打印
    }  

    int main(void)
    {
        pthread_t tid1, tid2;  

        // 创建 2 个线程
        pthread_create(&tid1, NULL, thread_fun_1, NULL);
        pthread_create(&tid2, NULL, thread_fun_2, NULL);  

        // 等待线程结束,回收其资源
        pthread_join(tid1, NULL);
        pthread_join(tid2, NULL);   

        return 0;
    }  

实际上,打印机是有做处理的,我在打印着的时候别人是不允许打印的,只有等我打印结束后别人才允许打印。这个过程有点类似于,把打印机放在一个房间里,给这个房间安把锁,这个锁默认是打开的。当 A 需要打印时,他先过来检查这把锁有没有锁着,没有的话就进去,同时上锁在房间里打印。而在这时,刚好 B 也需要打印,B 同样先检查锁,发现锁是锁住的,他就在门外等着。而当 A 打印结束后,他会开锁出来,这时候 B 才进去上锁打印。

而在线程里也有这么一把锁——互斥锁(mutex),互斥锁是一种简单的加锁的方法来控制对共享资源的访问,互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。

互斥锁的操作流程如下:

1)在访问共享资源后临界区域前,对互斥锁进行加锁。

2)在访问完成后释放互斥锁导上的锁。

3)对互斥锁进行加锁后,任何其他试图再次对互斥锁加锁的线程将会被阻塞,直到锁被释放。

互斥锁的数据类型是: pthread_mutex_t

互斥锁基本操作

以下函数需要的头文件:

#include <pthread.h>

1)初始化互斥锁

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

功能:

初始化一个互斥锁。

参数:

mutex:互斥锁地址。类型是 pthread_mutex_t 。

attr:设置互斥量的属性,通常可采用默认属性,即可将 attr 设为 NULL

可以使用宏 PTHREAD_MUTEX_INITIALIZER 静态初始化互斥锁,比如:

pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;

这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_mutex_init()
来完成动态初始化,不同之处在于 PTHREAD_MUTEX_INITIALIZER 宏不进行错误检查。

返回值:

成功:0,成功申请的锁默认是打开的。

失败:非 0 错误码

2)上锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

功能:

对互斥锁上锁,若互斥锁已经上锁,则调用者一直阻塞,直到互斥锁解锁后再上锁。

参数:

mutex:互斥锁地址。

返回值:

成功:0

失败:非 0 错误码

int pthread_mutex_trylock(pthread_mutex_t *mutex);

调用该函数时,若互斥锁未加锁,则上锁,返回 0;若互斥锁已加锁,则函数直接返回失败,即 EBUSY。

3)解锁

int pthread_mutex_unlock(pthread_mutex_t * mutex);

功能:

对指定的互斥锁解锁。

参数:

mutex:互斥锁地址。

返回值:

成功:0

失败:非 0 错误码

4)销毁互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

功能:

销毁指定的一个互斥锁。互斥锁在使用完毕后,必须要对互斥锁进行销毁,以释放资源。

参数:

mutex:互斥锁地址。

返回值:

成功:0

失败:非 0 错误码

互斥锁应用实例

我们通过互斥锁完善上面的例子,示例代码如下:

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

    pthread_mutex_t mutex; //互斥锁  

    // 打印机
    void printer(char *str)
    {
        pthread_mutex_lock(&mutex); //上锁
        while(*str!=‘\0‘)
        {
            putchar(*str);
            fflush(stdout);
            str++;
            sleep(1);
        }
        printf("\n");
        pthread_mutex_unlock(&mutex); //解锁
    }  

    // 线程一
    void *thread_fun_1(void *arg)
    {
        char *str = "hello";
        printer(str); //打印
    }  

    // 线程二
    void *thread_fun_2(void *arg)
    {
        char *str = "world";
        printer(str); //打印
    }  

    int main(void)
    {
        pthread_t tid1, tid2;  

        pthread_mutex_init(&mutex, NULL); //初始化互斥锁  

        // 创建 2 个线程
        pthread_create(&tid1, NULL, thread_fun_1, NULL);
        pthread_create(&tid2, NULL, thread_fun_2, NULL);  

        // 等待线程结束,回收其资源
        pthread_join(tid1, NULL);
        pthread_join(tid2, NULL);   

        pthread_mutex_destroy(&mutex); //销毁互斥锁  

        return 0;
    }
时间: 2024-08-02 13:54:41

互斥锁概念简单说明和举例的相关文章

Linux 同步方法剖析--内核原子,自旋锁和互斥锁

在学习 Linux® 的过程中,您也许接触过并发(concurrency).临界段(critical section)和锁定,但是如何在内核中使用这些概念呢?本文讨论了 2.6 版内核中可用的锁定机制,包括原子运算符(atomic operator).自旋锁(spinlock).读/写锁(reader/writer lock)和内核信号量(kernel semaphore). 本文还探讨了每种机制最适合应用到哪些地方,以构建安全高效的内核代码. 本文讨论了 Linux 内核中可用的大量同步或锁定

Python进阶(3)_进程与线程中的lock(互斥锁、递归锁、信号量)

1.同步锁 (Lock) 当各个线程需要访问一个公共资源时,会出现数据紊乱 例如: 1 import threading,time 2 def sub(): 3 global num #对全局变量进行操作 4 5 temp=num 6 time.sleep(0.001) #模拟线程执行中出现I/o延迟等 7 num=temp-1 #所有线程对全局变量进行减一 8 9 time.sleep(1) 10 11 num=100 12 l=[] 13 14 for i in range(100): 15

第9章 线程编程(4)_线程同步1:互斥锁

5. 线程的互斥和同步 5.1 同步和互斥的概念 (1)线程同步:是一个宏观概念,在微观上包含线程的相互排斥和线程的先后执行的约束问题.解决同步方式一般采用条件变量和信号量. (2)线程互斥:线程执行的相互排斥(注意,它不关心线程间执行的先后顺序!).解决互斥一般使用互斥锁.读写锁和信号量. [编程实验]银行ATM(线程不安全的例子) //account.h #ifndef __ACCOUNT_H__ #define __ACCOUNT_H__ typedef struct { int code

信号量、互斥锁,读写锁和条件变量的区别

信号量强调的是线程(或进程)间的同步:“信号量用在多线程多任务同步的,一个线程完成了某一个动作就通过信号量告诉别的线程,别的线程再进行某些动作(大家都 在sem_wait的时候,就阻塞在那里).当信号量为单值信号量是,也可以完成一个资源的互斥访问.有名信号量:可以用于不同进程间或多线程间的互斥与同步 创建打开有名信号量 sem_t *sem_open(const char *name, int oflag); sem_t *sem_open(const char *name, int oflag

ReactiveSwift源码解析(十一) Atomic的代码实现以及其中的Defer延迟、Posix互斥锁、递归锁

本篇博客我们来聊一下ReactiveSwift中的原子性操作,在此内容上我们简单的聊一下Posix互斥锁以及递归锁的概念以及使用场景.然后再聊一下Atomic的代码实现.Atomic主要负责多线程下的原子操作,负责共享资源的同步一致性.而在Atomic中就是使用到了Posix互斥锁和递归锁.在聊上述内容之前,我们先来回顾一下Swift语言中延迟执行defer的使用方式,在之前Swift编程的相关博客中也涉及到了defer的使用方式.defer因为Atomic使用到了延迟操作,所以下方我们再做一个

互斥锁 pthread_mutex_init()函数

Linux下为了多线程同步,通常用到锁的概念.posix下抽象了一个锁类型的结构:ptread_mutex_t.通过对该结构的操作,来判断资源是否可以访问.顾名思义,加锁(lock)后,别人就无法打开,只有当锁没有关闭(unlock)的时候才能访问资源. 即对象互斥锁的概念,来保证共享数据操作的完整性.每个对象都对应于一个可称为" 互斥锁" 的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象. 使用互斥锁(互斥)可以使线程按顺序执行.通常,互斥锁通过确保一次只有一个线程执行代

python多线程编程(2): 使用互斥锁同步线程

上一节的例子中,每个线程互相独立,相互之间没有任何关系.现在假设这样一个例子:有一个全局的计数num,每个线程获取这个全局的计数,根据num进行一些处理,然后将num加1.很容易写出这样的代码: # encoding: UTF-8import threadingimport time class MyThread(threading.Thread): def run(self): global num time.sleep(1) num = num+1 msg = self.name+' set

linux驱动开发(十一)linux内核信号量、互斥锁、自旋锁

参考: http://www.360doc.com/content/12/0723/00/9298584_225900606.shtml http://www.cnblogs.com/biyeymyhjob/archive/2012/07/21/2602015.html http://blog.chinaunix.net/uid-25100840-id-3147086.html http://blog.csdn.net/u012719256/article/details/52670098 --

关于互斥锁,条件变量的内核源码解析

一.解决问题和适用范围 主要是用来等待一个条件,这个条件可能需要另一个线程来满足这个条件.这个和我们平常适用的pthread_mutex_lock的最大不同在于后者保护的一般是一个代码段(也就是关键区),或者一个变量,但是由于一般来说这个变量的访问是在一个关键区中,所以可以认为是一个关键区. 但是对于条件变量,是需要的是一个事件,只有事件满足的时候才会执行后面的操作,此时就出现一个问题:如果不满足我们应该怎么办?如果如果使用简单信号量,可能另一方触发了这个条件,然后通过unlock来唤醒一个线程