Linux线程——互斥锁

已于 2024-04-23 21:49:03 修改
阅读量1k 收藏 24
点赞数 19
分类专栏： Linux系统编程 文章标签： linux
于 2023-12-19 22:32:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78772787/article/details/135093677
版权

目录

概念

常用API

创建互斥锁

函数原型

参数解读

返回值

销毁互斥锁

函数原型

参数解读

返回值

加锁互斥锁

函数原型

参数解读

返回值

解锁互斥锁

函数原型

参数解读

返回值

代码示例

互斥锁的创建及加锁解锁

互斥锁限制共享资源的访问

概念

互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。

如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。

在设计时需要规定所有的线程必须遵守相同的数据访问规则。只有这样，互斥机制才能正常工作。操作系统并不会做数据访问的串行化。如果允许其中的某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其它的线程在使用共享资源前都获取了锁，也还是会出现数据不一致的问题。

互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy。

常用API

包含的头文件

#include <pthread.h>

创建互斥锁

函数原型
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
参数解读
*mutex锁的地址，需定义一个pthread_mutex_t类型的全局变量。
attr互斥量的属性，一般设为NULL，要用默认的属性初始化互斥量，只需把attr设置为NULL。
返回值

若成功返回0，否则返回错误编号。

销毁互斥锁

函数原型
int pthread_mutex_destroy(pthread_mutex_t mutex);
参数解读

*mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量。

返回值

若成功返回0，否则返回错误编号。

加锁互斥锁

函数原型
int pthread_mutex_lock(pthread_mutex_t mutex);
参数解读

*mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量。

返回值

若成功返回0，否则返回错误编号。

如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。

解锁互斥锁

函数原型
int pthread_mutex_unlock(pthread_mutex_t *mutex);
参数解读

*mutex：锁的地址，需定义一个pthread_mutex_t类型的全局变量。

返回值

若成功返回0，否则返回错误编号。

代码示例

互斥锁的创建及加锁解锁

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

int data = 0;

pthread_mutex_t mutex;//定义一个互斥锁

void *func1(void *arg)
{
	int i;
	pthread_mutex_lock(&mutex);//上锁 执行到该锁时会进行其中代码 直到解锁后才会进行其他代码
	for(i=0;i<5;i++)
	{
        	printf("t1:this thread t1:%ld \n",(unsigned long)pthread_self());
        	printf("t1:num=%d\n",*((int *)arg));
	}
    pthread_mutex_unlock(&mutex);//解锁

}

void *func2(void *arg)
{
        pthread_mutex_lock(&mutex);
        printf("t2:this thread t2:%ld \n",(unsigned long)pthread_self());
        printf("t2:num=%d\n",*((int *)arg));
        pthread_mutex_unlock(&mutex);
}

int main()
{
        int ret;
        int num =999;
        pthread_t t1;
	    pthread_t t2;
	
	    pthread_mutex_init(&mutex,NULL);//初始化互斥锁
	
        ret = pthread_create(&t1,NULL,func1,(void *)&num);
        if(ret == 0)
	    {
                printf("main:create t1 success\n");
        }

	    ret = pthread_create(&t2,NULL,func2,(void *)&num);
        if(ret == 0)
        {
                printf("main:create t2 success\n");
        }

        printf("main:%ld\n",(unsigned long)pthread_self());	

	    pthread_join(t1,NULL);
	    pthread_join(t2,NULL);	

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

由编译结果可知：t1会被main函数打断，但是不会被t2,t3打断,t1运行后t2,t3才能运行。

互斥锁限制共享资源的访问

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

int data = 0;

pthread_mutex_t mutex;

void *func1(void *arg)
{
    printf("t1:this thread t1:%ld \n",(unsigned long)pthread_self());
    printf("t1:num=%d\n",*((int *)arg));
	pthread_mutex_lock(&mutex); //上锁后执行下面语句
	while(1)
	{
		printf("ti:%d\n",data++);
		sleep(1);
		if(data==3)
		{
			pthread_mutex_unlock(&mutex);//解锁
			printf("over!!!!!!!!!!!!!!!!!!\n");//执行后结束func1线程
	//		pthread_exit(NULL);
			exit(0);//执行后结束整个进程
		}
	}
}

void *func2(void *arg)
{
    printf("t2:this thread t2:%ld \n",(unsigned long)pthread_self());
    printf("t2:num=%d\n",*((int *)arg));
	while(1)
	{
		printf("t2:%d\n",data);
		pthread_mutex_lock(&mutex);//func2进入检测锁的循环 判断func1是否解锁
		data++;
        pthread_mutex_unlock(&mutex);
		sleep(1);
	}
}

int main()
{
        int ret;
        int num =999;
        pthread_t t1;
	    pthread_t t2;
	
	    pthread_mutex_init(&mutex,NULL);
	
        ret = pthread_create(&t1,NULL,func1,(void *)&num);
        if(ret == 0)
	    {
            printf("main:create thread success\n");
        }

	    ret = pthread_create(&t2,NULL,func2,(void *)&num);
        if(ret == 0)
        {
            printf("main:create thread success\n");
        }

        printf("main:%ld\n",(unsigned long)pthread_self());	

	    while(1)
	    {
		    printf("main:%d\n",data);
		    sleep(1);
	    }
	
	    pthread_join(t1,NULL);
	    pthread_join(t2,NULL);	

	    pthread_mutex_destroy(&mutex);
        return 0;
}

由编译结果可知，func1线程结束后整个进程结束。

嵌入式JunG
关注
专栏目录
并发与竞争——互斥锁
tyustli
04-13 365
f互斥锁的实现。
linux 互斥锁
北京-大白的博客
04-10 309
原子操作 原子操作：最小的执行单位，执行时不可能被其他任务或事件打断，由于其特性因此用汇编编写。主要　用于资源计数（如引用计数，其实现主要利用volatile变量直接从寄存器中读值，防止编译器优化） 互斥锁主要在多线程编程中保护共享资源，确保对关键代码段的独占式访问。对共享资源的访问，要对互斥量进行加锁，如果互斥量已经上了锁，调用线程会阻塞，直到互斥量被解锁。在完成了对共享资源的访问后，要对互...
Linux 互斥锁
weixin_34292924的博客
09-21 236
互斥的概念 在多线程编程中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。 每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻， 只能有一个线程访问该对象。 互斥锁操作 互斥锁也可以叫线程锁，接下来说说互斥锁的的使用方法。 对互斥锁进行操作的函数，常用的有如下几个： #include &lt;pthread.h&gt; int pthread_mu...
Linux线程（十）线程互斥锁-互斥锁概念详解
最新发布
Dola的博客
10-08 1234
互斥锁（mutex）又叫互斥量，从本质上说是一把锁，在访问共享资源之前对互斥锁进行上锁，在访问完成后释放互斥锁（解锁）；对互斥锁进行上锁之后，任何其它试图再次对互斥锁进行加锁的线程都会被阻塞，直到当前线程释放互斥锁。如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。
Linux互斥锁
happylzs2008的专栏
04-07 198
嵌入式 Linux线程锁详解pthread_mutexattr_t【转】 https://www.cnblogs.com/sky-heaven/p/6841687.html pthread_mutexattr_init https://blog.csdn.net/pugu12/article/details/46865843 pthread锁之pthread_mutexattr...
详解linux多线程——互斥锁、条件变量、读写锁、自旋锁、信号量
Linuxhus的博客
11-03 353
如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。3. 非繁忙等待：如果一个线程已经锁定了一个互斥量，第二个线程又试图去锁定这个互斥量，则第二个线程将被挂起（不占用任何cpu资源），直到第一个线程解除对这个互斥量的锁定为止，第二个线程则被唤醒并继续执行，同时锁定这个互斥量。在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。
多线程编程（二）——互斥锁与死锁问题
ypt
05-02 923
二元信号量提供了一种很方便的方法来确保对共享变量的互斥访问，即每个共享变量与一个信号量 s（初始为1）联系起来，然后P（s）和V（s）操作将相应的临界区包围起来。互斥锁是以提供互斥为目的的二元信号量，二者均属于挂起等待锁。互斥锁（针对于线程）互斥锁用于确保同一时间只有一个线程能访问被互斥锁保护的资源（互斥锁是针对于线程的）。锁定互斥量的线程与解锁互斥量的线程必须是同一个线程。互斥锁的引入必须对互斥...
Linux c++ 多线程编程基础——互斥锁
PurpleDream的博客
04-12 1832
1. 前言    本来是想整理一份多线程编程的博客，才发现C++的多线程比Java还要坑。涉及的范围实在有点广，所以之后分开来慢慢讲解，先说这个互斥锁。    首先是互斥，这是什么呢？说起来就又是一张的内容，详细自己去了解一下，参考书籍《操作系统——精髓与设计原理(第七版)》第五章，我这里将要说一下就好了。    互斥就是有一个进程使用了一个临界区的资源，另一个进程就无法使用。举个例子吧，在交通道...
linux进程间同步——互斥锁与条件变量
dongtaintailiang的博客
07-18 441
互斥锁 创建 //互斥锁是静态分配的（不是动态申请的） static pthread_mutex_t mutex_lock = PETHREAD_MUTEX_INITIALIZER; 加/解锁 #include <prhread.h> int pthread_mutex_lock(pthread_mutex_t mutex_lock); int pthread_mutex_trylock(pthread_mutex_t mutex_lock); //如果互斥锁被锁住，返回 E
Linux—互斥锁
weixin_61701822的博客
04-02 542
互斥锁的使用包括初始化互斥锁、互斥锁上锁、互斥锁解锁、互斥锁释放
【Linux 互斥锁】
Sugar_wolf的博客
05-31 374
【Linux 互斥锁】
【Linux】互斥锁
qq_37924645的博客
05-30 256
mutex (互斥量) 多个线程同时访问共享数据时可能会冲突，比如 两个线程都要把某个全局变量增加 1，这个操作在某平台需要三条指令完成： 1. 从内存读变量值到寄存器 2. 寄存器的值加1 3. 将寄存器的值写回内存 对于多线程的程序，访问冲突的问题是很普遍的，解决的办法是引入互斥锁(Mutex,Mutual Exclusive Lock)，获得锁的线程可以完成“读-修改-写”的操作，
Linux多线程同步：互斥锁、条件变量与信号量解析
"这篇文档介绍了Linux系统中用于多线程同步的三种机制——互斥锁、条件变量和信号量，重点讲述了互斥锁的概念、使用方法以及注意事项，以确保对共享资源的正确访问和管理。" 在多线程编程中，尤其是在Linux环境下，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值