linux线程同步方式1——互斥锁（mutex）

最新推荐文章于 2022-06-26 16:04:23 发布
最新推荐文章于 2022-06-26 16:04:23 发布
阅读量1.1k 收藏 4
点赞数 4
分类专栏： linux 文章标签： linux mutex pthread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JMW1407/article/details/106737453
版权

互斥锁（mutex）

互斥体

  • 互斥体实现了“互相排斥”（mutual exclusion）同步的简单形式（所以名为互斥体(mutex)）。互斥体禁止多个线程同时进入受保护的代码“临界区”（critical section）。因此，在任意时刻，只有一个线程被允许进入这样的代码保护区。
  • 任何线程在进入临界区之前，必须获取（acquire）与此区域相关联的互斥体的所有权。如果已有另一线程拥有了临界区的互斥体，其他线程就不能再进入其中。这些线程必须等待，直到当前的属主线程释放（release）该互斥体。
  • 什么时候需要使用互斥体呢？互斥体用于保护共享的易变代码，也就是，全局或静态数据。这样的数据必须通过互斥体进行保护，以防止它们在多个线程同时访问时损坏

互斥锁

1、定义

  • 为了保证共享数据操作的完整性。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
  • 使用互斥锁（互斥）可以使线程按顺序执行。通常，互斥锁通过确保一次只有一个线程执行代码的临界段来同步多个线程。互斥锁还可以保护单线程代码
    在这里插入图片描述
    一段需要互斥执行的代码称为临界区。线程在进入临界区之前，首先尝试加锁lock()，如果成功，则进入临界区，此时称这个线程持有锁；否则，就等待，直到持有锁的线程解锁；持有锁的线程执行完临界区的代码后，执行解锁unlock()。
    在这里插入图片描述

2、属性

  • 原子性：把一个互斥锁定义为一个原子操作，这意味着操作系统保证了如果一个线程锁定了互斥锁，则没有其他线程可以在同一时间成功锁定这个互斥量。
  • 唯一性：如果一个线程锁定一个互斥量，在它接触锁定之前，没有其他线程可以锁定这个互斥量。
  • 非繁忙等待：如果一个线程已经锁定了一个互斥锁，第二个线程又试图去锁定这个互斥锁，则第二个线程将被挂起（不占用CPU资源），直到第一个线程解锁，第二个线程则被唤醒并继续执行，同时锁定这个互斥量

3、使用流程（相关API函数）

  1. 互斥锁初始化和销毁的函数原型：
 int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);

int pthread_mutex_destroy(pthread_mutex_t *mutex);
  1. 互斥锁的上锁和解锁的函数原型为：
int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

pthread_mutex_init()

#include <pthread.h>//头文件

1、定义

互斥锁的初始化

2、函数原型：

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

  • pthread_mutex_t： 定义互斥体机制完成多线程的互斥操作，该机制的作用是对某个需要互斥的部分，在进入时先得到互斥体，如果没有得到互斥体，表明互斥部分被其它线程拥有，此时欲获取互斥体的线程阻塞，直到拥有该互斥体的线程完成互斥部分的操作为止。

  • mutex：是指向要初始化的互斥锁的指针。

  • attr: 是指向属性对象的指针，该属性对象定义要初始化的互斥锁的属性。如果该指针为 NULL，则使用默认的属性。，默认属性为快速互斥锁

    • PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。
    • PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。
    • PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样保证当不允许多次加锁时不出现最简单情况下的死锁。
    • PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。
pthread_mutex_t mutex; 
pthread_mutex_init(&mutex, NULL); //按缺省的属性初始化互斥体变量mutex

3、返回值:

成功则返回0, 出错则返回错误编号.

4、初始化方式

  • 静态初始化：如果互斥锁 mutex 是静态分配的（定义在全局，或加了static关键字修饰），可以直接使用宏进行初始化。
pthead_mutex_t   muetx = PTHREAD_MUTEX_INITIALIZER;
  • 动态初始化：局部变量应采用动态初始化。
pthread_mutex_init(&mutex, NULL)

pthread_mutex_destroy（）

1、定义

mutex 指向要销毁的互斥锁的指针

2、函数原型

int pthread_mutex_destroy(pthread_mutex_t *mutex);

互斥锁销毁函数在执行成功后返回 0，否则返回错误码。

pthread_mutex_lock（）(阻塞）

1、定义

对共享资源的访问, 要对互斥量进行加锁, 如果互斥量已经上了锁, 调用线程会阻塞, 直到互斥量被解锁. 在完成了对共享资源的访问后, 要对互斥量进行解锁。

2、函数原型

int pthread_mutex_lock(pthread_mutex_t *mutex);

返回值: 成功则返回0, 出错则返回错误编号.

int pthread_mutex_trylock(pthread_mutex_t *mutex);

说明: 具体说一下trylock函数, 这个函数是非阻塞调用模式, 也就是说, 如果互斥量没被锁住, trylock函数将把互斥量加锁, 并获得对共享资源的访问权限; 如果互斥量被锁住了, trylock函数将不会阻塞等待而直接返回EBUSY, 表示共享资源处于忙状态。

3、基于mutex类型的返回值

  • 如果mutex 对象的type是 PTHREAD_MUTEX_NORMAL，不进行deadlock detection(死锁检测)。企图进行relock，这个mutex会导致deadlock.如果一个线程对未加锁的或已经unlock的mutex对象进行unlock操作，结果是不未知的。
  • 如果mutex类型是PTHREAD_MUTEX_ERRORCHECK，那么将进行错误检查。如果一个线程企图对一个已经锁住的mutex进行relock，将返回一个错误。如果一个线程对未加锁的或已经unlock的mutex对象进行unlock操作，将返回一个错误。
  • 如果mutex类型是 PTHREAD_MUTEX_RECURSIVE，mutex会有一个锁住次数（lock count）的概念。当一个线程成功地第一次锁住一个mutex的时候，锁住次数（lock count）被设置为1，每一次一个线程unlock这个mutex的时候，锁住次数（lock count）就减1。当锁住次数（lock count）减少为0的时候，其他线程就能获得该mutex锁了。如果一个线程对未加锁的或已经unlock的mutex对象进行unlock操作，将返回一个错误。
  • 如果mutex类型是 PTHREAD_MUTEX_DEFAULT，企图递归的获取这个mutex的锁的结果是不确定的。unlock一个不是被调用线程锁住的mutex的结果也是不确定的。企图unlock一个未被锁住的mutex导致不确定的结果。

pthread_mutex_unlock（）

1、定义

函数释放有参数mutex指定的mutex对象的锁

2、函数原型

int pthread_mutex_unlock(pthread_mutex_t *mutex);

返回值: 成功则返回0, 出错则返回错误编号.

互斥锁应用举例

由于共享、竞争而没有加任何同步机制，导致产生于时间有关的错误，造成数据混乱：
1、不使用互斥锁

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
 
void *tfn(void *arg)
{
     for(int i =0;i < 5;i++)
      {
        printf("hi, ");
        sleep(1);
        printf(" boy \n");      
        sleep(1);
      }
    return NULL;
}
 
int main(void)
{
   
    pthread_t tid;
    pthread_create(&tid, NULL, tfn, NULL);
    for(int i =0;i < 5;i++)
      {
        printf("hello, ");
        sleep(1);
        printf(" girl\n");      
        sleep(1);
      }
    pthread_join(tid , NULL);
    return 0;
}

在这里插入图片描述
输出结果无序

2、使用互斥锁

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

pthread_mutex_t mutex; 

void *tfn(void *arg)
{
     for(int i =0;i < 5;i++)
      {
        pthread_mutex_lock(&mutex); 
	printf("hi, ");
        sleep(1);
        printf(" boy \n");  
	pthread_mutex_unlock(&mutex);     
        sleep(1);
      }
    return NULL;
}
 
int main(void)
{
   
    pthread_t tid;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&tid, NULL, tfn, NULL);
    for(int i =0;i < 5;i++)
      {
        printf("hello, ");
        sleep(1);
        printf(" girl\n");      
        sleep(1);
      }
    pthread_mutex_destroy(&mutex);
    pthread_join(tid , NULL);
    return 0;
}

在这里插入图片描述
输出结果有序

3、多个线程实验

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
 
pthread_mutex_t mutex;
int val = 0;
void *ThreadFunc(void *arg)
{	
	while(1)
	{
		pthread_mutex_lock(&mutex); /*获取互斥锁*/
		int i = 0;
		for(i = 0 ; i < 10000 ; i++)
		{
			val++;
		}
		printf("val = %d\n" , val);
		pthread_mutex_unlock(&mutex); /*释放互斥锁*/
		usleep(20);
	}
	
	return 0;
}
 
int main()
{
	void *ResVal;
	pthread_mutex_init (&mutex, NULL); /*定义*/
	pthread_t thread1 , thread2;
	pthread_create(&thread1 , NULL , ThreadFunc , NULL);
	pthread_create(&thread2 , NULL , ThreadFunc , NULL);
	pthread_join(thread1 , &ResVal);
	pthread_join(thread2 , &ResVal);
}

若使用互斥锁，则val永远是以10000位单位自加，不使用互斥锁，输出结果无序，不可控。

参考

1、https://www.cnblogs.com/biyeymyhjob/archive/2012/07/21/2602015.html
2、https://www.cnblogs.com/zhanghongfeng/p/10294975.html
3、https://blog.csdn.net/qq_24373811/article/details/52371792
4、https://blog.csdn.net/qq_39736982
5、https://blog.csdn.net/wssjn1994/article/details/86064852
6、https://www.cnblogs.com/jiu0821/p/6100824.html

JMW1407
关注
专栏目录
Linux中RT-Mutex实现
qq_37057338的博客
07-31 851
本文主要梳理优先级继承的基本原理，优先级继承主要是用来解决优先级反转，可以简单理解为一个进程在当前进程拥有的锁上阻塞时，会继承另一个进程的优先级。举个例子说明，进程A、B、C，其中A优先级最高，B次之，C最小，那么当 A 在 C 拥有的锁上阻塞时，C 将继承 A 的优先级。因此，如果 B 变为可运行状态，它将不会抢占 C，因为此时 C 具有 A 的高优先级。一旦 C 释放锁，它将失去继承的优先级，然后 A 可以继续使用 C 拥有的资源。
详解linux多线程——互斥锁、条件变量、读写锁、自旋锁、信号量
最新发布
Linuxhus的博客
11-03 304
如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。3. 非繁忙等待：如果一个线程已经锁定了一个互斥量，第二个线程又试图去锁定这个互斥量，则第二个线程将被挂起（不占用任何cpu资源），直到第一个线程解除对这个互斥量的锁定为止，第二个线程则被唤醒并继续执行，同时锁定这个互斥量。在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。
互斥锁、自旋锁和读写锁
rongwenbin的专栏
01-17 2308
一、互斥锁 对于多线程的程序，访问冲突的问题是很普遍的，解决的办法是引入互斥锁（Mutex，MutualExclusive Lock），获得锁的线程可以完成“读-修改-写”的操作，然后释放锁给其它线程，没有获得锁的线程只能等待而不能访问共享数据，这样“读-修改-写”三步操作组成一个原子操作，要么都执行，要么都不执行，不会执行到中间被打断，也不会在其它处理器上并行做这个操作。 Mutex用p
Linux mutex用法和原理分析
06-12 1426
一、multex的使用套路 1.mutex实例对象创建 struct mutex mutex; 2.初始化multex mutex_init(&globalmem_devp->mutex); 3.用锁保护资源 mutex_lock(&dev->mutex); memset(dev->mem, 0, GLOBALMEM_SIZE); mutex_unlock(&dev->mutex); 二、实际上mutex_lock/mutex_unlock的实现
Linux线程同步与互斥
weixin_34210740的博客
01-01 146
● 互斥锁 互斥锁用来保证同一时间内只有一个线程在执行某段代码（临界区）。多线程编程最容易出问题的地方，就是临界区的界定和访问控制。下面是一个生产者，消费者的简单例子。生产者、消费者公用一个缓冲区，这里假定缓冲区只能存放一条消息。 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;pthread.h&gt; ...
Linux线程同步（一）之使用互斥量（互斥锁）
yishizuofei的博客
10-11 642
线程同步的理解当多个控制线程共享相同的内存时，需要确保每个线程看到一致的数据视图。如果每个线程使用的变量都是其他线程不会读取或修改的，那么就不存在一致性问题。同样地，如果变量是只读的，多个线程同时读取该量也不会有一致性问题。但是，当某个线程可以修改变量，而其他线程也可以读取或者修改这个变量的时候，就需要对这些线程进行同步，以确保它们在访问变量的存储内容时不会访问到无效的数据。互斥量的概念可以通过使用
linux mutex
weixin_30835933的博客
04-20 77
#include <iostream> #include <queue> #include <cstdlib> #include <unistd.h> #include <pthread.h> using namespace std; pthread_mutex_t mutex; queue<int&g...
【Linux】线程同步（互斥锁）
xiaoxiaoguailou的博客
11-28 452
文章目录（一）互斥锁（二）互斥锁的调用接口（三）互斥锁的简单使用 （一）互斥锁 互斥锁（互斥量）：允许程序员锁住某个对象，使得的每次只有一个线程访问它。 为了控制对关键代码的访问，必须在进入这段代码之前锁住一个互斥量，在完成关键代码执行后解锁。 （二）互斥锁的调用接口 头文件：pthread.h 依赖pthread线程库 （1）初始化锁 int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* mutexattr);
Linux线程同步之——互斥量(Mutex)
huangjh2017的博客
03-07 4869
当我们在进行多线程编程的时候，如果有多个线程共享相同的内存时，我们需要确保每个线程看到一致的数据视图。如果每个线程使用的变量都是其他线程不会读取和修改的，或对每个线程是只读的，那么久不存在一致性的问题。但是，当一个线程可以修改变量，其他线程同样也能读取或修改变量的时候，我们就需要对这些线程进行同步。在Linux上进行多线程编程时，我们常用到互斥量(Mutex)。 　　互斥量(Mutex)从本质上说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放锁。当我们对互斥量进行加锁之后，任何其他试图再次对互
linux编程练习——使用多线程实现买票窗口（线程同步问题）引入互斥锁
qq_42579966的博客
06-26 1004
多线程实现买票——引入线程同步
Linux c++ 多线程编程基础——互斥锁
PurpleDream的博客
04-12 1803
1. 前言    本来是想整理一份多线程编程的博客，才发现C++的多线程比Java还要坑。涉及的范围实在有点广，所以之后分开来慢慢讲解，先说这个互斥锁。    首先是互斥，这是什么呢？说起来就又是一张的内容，详细自己去了解一下，参考书籍《操作系统——精髓与设计原理(第七版)》第五章，我这里将要说一下就好了。    互斥就是有一个进程使用了一个临界区的资源，另一个进程就无法使用。举个例子吧，在交通道...
Linux基础——线程同步之互斥锁
l1206715877的博客
06-20 549
线程同步的必要性       在线程当中，变量是可以被共享的，那么我们在不同的线程，对同一个变量进行操作的时候就会出现一些问题：两个线程同时对一个变量操作（假如对一个变量i进行加1），有可能就会出现数据混乱（即每线程对i+1但是结果不是真正的结果），注意：线程是并发的，出现这种情况很正常。下面写个例子演示一下。 #include <stdio.h> #include <stdlib.h> #include <pth
Linux mutex
修也
07-14 202
#include"../common" /*https://github.com/XiuyeXYE/cpp*/ void *thread_function(void *arg); pthread_mutex_t work_mutex; /* protects both work_area and time_to_exit */ #define WORK_SIZE 1024 char work_area[WORK_SIZE]; int time_to_exit = 0; int main()..
Linux线程同步(二)---互斥锁实现线程同步
myselfzhangji的博客
09-05 413
一 why 先给自己打个广告，本人的微信公众号:嵌入式Linux江湖，主要关注嵌入式软件开发，股票基金定投，足球等等，希望大家多多关注，有问题可以直接留言给我，一定尽心尽力回答大家的问题。 在博客《Linux线程同步(一)—“初识篇”》中，介绍了为什么需要线程同步，从本篇博客开始介绍如何实现线程同步，本篇主要介绍的是互斥锁实现线程同步。 二 how 互斥锁：只能被一个线程拥有，比如线程A拥有了这把锁，其他线程都无法拥有这把锁。只有获得这把锁的线程才可以访问临界区,其他没有获得这把锁的线程都无法访问临界区
linux同步机制_互斥量(mutex)
xiaolz88的博客
06-22 462
一.linux中线程间通信同步机制方法1——互斥量(mutex) 1.为啥要有互斥量？ 在linux编程享受多线程带来便利的同时，也需要注意多线程在访问一段共享资源的代码片段(术语:临界区)，这段代码的执行不应该被其他线程中断，要保证这段代码的执行是原子操作。 其中linux中的互斥量就可以保证多线程对共享资源访问的时的原子操作。当然还有其他的方法，比如：条件变量。本文我们只介绍互斥量(mutex). 二.互斥量的使用方法 2.1.静态分配的互斥量且使用默认属性 初始化直接使用PTHREAD_MUTEX_I
linux 应用程序 mutex,Linux mutex 编程
weixin_35712036的博客
05-07 245
两个并行运行的程序片断，如线程，同时读写同一块内存，其结果是不确定的。这时候我们需要互斥锁，保证一个线程先读写完，然后另一个线程才可以读写。1 没有使用mutex的例子$ cat mutex-example-1.c#include //ptrinf#include //pthread_xxx#include //sleepint global_para = 0;void *do_...
Linux mutex编程
fujianyuqiang的专栏
08-18 656
#include #include #include #include #include #include //thread_functtion void * thread_function(void * arg); //mutex pthread_mutex_t work_mutex; #define WORK_SIZE 1024 char work_area[WORK_SIZE]; int
关于Linux应用mutex的使用
hunter168_wang的专栏
03-11 414
关于Linux应用mutex的使用 互斥锁是通过锁的机制来实现线程间的同步问题。互斥锁的基本流程为： int pthread_mutex_init(pthread_mutex_t * mutex , pthread_mutexattr_t * attr); int pthread_mutex_destroy (pthread_mutex_t * mutex); int pthread_mutex_lock (pthread_mutex_t * mutex ); int pthread_mutex.
Linux多线程同步：互斥锁、条件变量与信号量解析
"这篇文档介绍了Linux系统中用于多线程同步的三种机制——互斥锁、条件变量和信号量，重点讲述了互斥锁的概念、使用方法以及注意事项，以确保对共享资源的正确访问和管理。" 在多线程编程中，尤其是在Linux环境下，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值