pthread_mutex 应用

最新推荐文章于 2025-06-01 13:55:23 发布
原创 最新推荐文章于 2025-06-01 13:55:23 发布 · 9.6k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#thread #null #function #join #attributes #linux

本文详细介绍了pthread互斥锁的使用方法，包括初始化、销毁、上锁与解锁等操作，并通过示例代码展示了如何正确使用互斥锁来保护共享资源。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、 pthread_mutex 家庭成员：

1.int pthread_mutex_init (pthread_mutex_t *mutex , pthread_mutexattr_t * attr );

Description

The pthread_mutex_init function initializes the given mutex with the given attributes. Ifattr is null, then the default attributes are used.


2. int pthread_mutex_destroy (pthread_mutex_t *mutex );

Description

The pthread_mutex_destroy function destroys the given mutex. If the mutex is already destroyed, thenerrno is set to EINVAL. If the mutex is locked, then errno is set to EBUSY.


3.int pthread_mutex_lock (pthread_mutex_t *mutex );

Description

The pthread_mutex_lock function locks the given mutex. If the mutex is already locked, then the calling thread blocks until the thread that currently holds the mutex unlocks it.


4.int pthread_mutex_trylock (pthread_mutex_t *mutex );

Description

The pthread_mutex_trylock function tries to lock the given mutex. If the mutex is already locked, the function returns without waiting for the mutex to be unlocked.

Returns

The pthread_mutex_trylock function returns zero if the call is successful, otherwise it setserrno to EINVAL and returns -1.


5.int pthread_mutex_unlock (pthread_mutex_t *mutex );

Description

The pthread_mutex_unlock function unlocks the given mutex.


二、成员作用

1.  互斥锁的初始化和销毁

.初始化有两种初始化方式:

a.   对于静态分配的互斥锁一半用宏赋值的方式初始化

eg:static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;


b.   对于动态分配的互斥锁（如调用malloc）或分配在共享内存中，则必须调用

pthread_mutex_init(pthread_mutex*mutex, pthread_mutexattr_t *mutexattr)函数来进行初始化。

动态分配释放例子：
pthread_mutex_init(*mutex ,*attr);
pthread_mutex_destory(*mutex)
pthread_mutexattr_init(*attr)
pthread_mutexattr_destory(*attr)动态分配的代码：
pthread_mutex_t *lock;
lock=(pthread_mutex_t *)malloc(sizeof(szieof(pthread_mutex_t)));
pthread_mutex_init(lock ,NULL);

. 互斥锁摧毁
pthread_mutex_destory(lock);
free(lock);

销毁一个互斥锁即意味着释放它所占用的资源，且要求锁当前处于开放状态。由于在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。

2.  互斥锁上锁、尝试上锁和解锁

        要对公共变量进行上锁来进行保护，必须最少要上两个锁以上，换句话说就得调用pthread_mutex_lock()函数两次以上，否则，只是上一个锁会达不到相应的效果。尝试上锁pthread_mutex_trylock()和pthread_mutex_lock()的区别是：后者会阻塞等待另外一个锁被解锁；前者尝试去加锁，如果不成功就返回非0，如果成功返回0，不会产生阻塞。

       每次上锁之后，一定要解锁，否则会造成程序一直在阻塞状态。


三、代码讲解：

代码说明1：互斥锁基本应用

#include<stdio.h>

#include<pthread.h>

#include"unistd.h"

pthread_mutex_tmutex = PTHREAD_MUTEX_INITIALIZER;

intcount = 0;

void*consume( void *arg)

{

while(1 )

{

pthread_mutex_lock(&mutex );

printf("************************consumebegin lock\n");

printf("************************consumed%d\n",count );

sleep(2);

count++;

printf("************************consumed%d\n",count);

printf("************************consumeover lock\n");

pthread_mutex_unlock(&mutex );

printf("************************I'mout of pthread_mutex\n");

sleep(1);

}

}

void* produce( void * arg )

{

while(1 )

{

pthread_mutex_lock(&mutex );

printf("productbegin lock\n");

printf("Produced %d\n", count );

printf("productover lock\n");

pthread_mutex_unlock(&mutex );

printf("I'mout of pthread_mutex\n");

sleep(1);

}

}

intmain( void )

{

pthread_tthread1,thread2;

pthread_create(&thread1, NULL, &produce, NULL );

pthread_create(&thread2, NULL, &consume, NULL );

pthread_join(thread1,NULL);

pthread_join(thread2,NULL);

return0;

}



结果显示：

[elbort@elborttest1]$ gcc -Wall -lpthread -o test test.c

[elbort@elborttest1]$ ./test

productbegin lock

Produced0

productover lock

I'mout of pthread_mutex

************************consumebegin lock

************************consumed0

/*中间等待了2秒但是product线程没有执行|*/

************************consumed1

************************consumeover lock

************************I'mout of pthread_mutex

productbegin lock

Produced1

productover lock

I'mout of pthread_mutex

************************consumebegin lock

************************consumed1

************************consumed2

************************consumeover lock

************************I'mout of pthread_mutex

productbegin lock

Produced2

productover lock

I'mout of pthread_mutex


/************************************************************************/


代码说明2：单一调用互斥锁没效果

void*consume( void *arg)

{

while(1 )

{

pthread_mutex_lock(&mutex );

printf("************************consumebegin lock\n");

printf("************************consumed%d\n",count );

sleep(2);

count++;

printf("************************consumed%d\n",count);

printf("************************consumeover lock\n");

pthread_mutex_unlock(&mutex );

printf("************************I'mout of pthread_mutex\n");

sleep(1);

}

}

void* produce( void * arg )

{

while(1 )

{

count=count+5;

printf("Produced %d\n", count );

sleep(1);

}

}

intmain( void )

{

pthread_tthread1,thread2;

pthread_create(&thread1, NULL, &produce, NULL );

pthread_create(&thread2, NULL, &consume, NULL );

pthread_join(thread1,NULL);

pthread_join(thread2,NULL);

return0;

}

~

~

结果说明：

[elbort@elborttest1]$ ./test

Produced5

************************consumebegin lock

************************consumed5

Produced10 //线程comsume被中断，conut的值被线程product修改

************************consumed11

************************consumeover lock

************************I'mout of pthread_mutex




/********************************************************/

代码说明3：pthread_mutex_trylock作用

intcount = 0;

void*consume( void *arg)

{

while(1 )

{

pthread_mutex_lock(&mutex );

printf("************************consumebegin lock\n");

printf("************************consumed%d\n",count );

sleep(2);

count++;

printf("************************consumed%d\n",count);

printf("************************consumeover lock\n");

pthread_mutex_unlock(&mutex );

printf("************************I'mout of pthread_mutex\n");

sleep(1);

}

}

void* produce( void * arg )

{

while(1 )

{

if(pthread_mutex_trylock(&mutex ) == 0)

{

printf("productbegin lock\n");

count++;

printf("Produced %d\n", count );

printf("productover lock\n");

pthread_mutex_unlock(&mutex );

printf("I'mout of pthread_mutex\n");

sleep(1);

}

else

{

printf("Ihave try!But i can lock the mutex!\n");

sleep(1);

}

}

}

intmain( void )

{

pthread_tthread1,thread2;

pthread_create(&thread1, NULL, &produce, NULL );

pthread_create(&thread2, NULL, &consume, NULL );

pthread_join(thread1,NULL);

pthread_join(thread2,NULL);

return0;

}


结果显示：

[elbort@elborttest1]$ ./test

************************consumebegin lock

************************consumed0

Ihave try!But i can lock the mutex!

Ihave try!But i can lock the mutex!

************************consumed1

************************consumeover lock

************************I'mout of pthread_mutex

productbegin lock

Produced2

productover lock

I'mout of pthread_mutex

************************consumebegin lock

************************consumed2

Ihave try!But i can lock the mutex!

Ihave try!But i can lock the mutex!

************************consumed3

************************consumeover lock

************************I'mout of pthread_mutex

productbegin lock

Produced4

productover lock

I'mout of pthread_mutex


Linux pthread_mutex_init()函数使用总结
程序猿老樊的博客
07-31 2653
Linux线程同步，通常都是使用锁来完成。posix下抽象了一个锁类型的结构：ptread_mutex_t。通过对该结构的操作，来判断资源是否可以访问。顾名思义，加锁(lock)后，别人就无法打开，只有当锁没有关闭(unlock)的时候才能访问资源。 对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。 使用互斥锁（互斥）可以使线程按顺序执行。通常，互斥锁通过确保...
打通用户态程序和内核系列之二：pthread_mutex_lock的实现
cbiqlux89468585的博客
09-01 842
一个很容混淆的地方是，误以为用户程序锁API的实现和接口，最终也会调用内核相关的锁操作提供的API。 应用程序锁API接口 主要的API有：pthread_mutex_lock; 相关说明如下： NAME pthread_mutex_lock -- lock a mutex SYNOPSIS #include <pthread.h> int ...
pthread_mutex
12-17
linux 同步与互斥 posix 线程互斥 实现 。（此为博客http://blog.youkuaiyun.com/shallnet 文章对应源码下载）
互斥锁 pthread_mutex_init()函数
热门推荐
yasi_xi的专栏
02-12 9万+
转自：http://hi.baidu.com/jingweiyoung/item/55a895cc22b8abdeee183bb0 linux下为了多线程同步，通常用到锁的概念。 posix下抽象了一个锁类型的结构：ptread_mutex_t。通过对该结构的操作，来判断资源是否可以访问。顾名思义，加锁(lock)后，别人就无法打开，只有当锁没有关闭(unlock)的时候才能访
实现Windows平台下的pthread库应用
最新发布
weixin_42607969的博客
06-01 417
pthread，全称POSIX线程，是IEEE POSIX标准定义的线程库。它广泛应用于UNIX/Linux系统中，提供了一系列创建和操作线程的函数。pthread库不仅支持多线程编程，还为线程的同步、调度等提供了丰富的API接口。在多核处理器越来越普及的今天，pthread让程序开发者能够充分利用硬件资源，实现程序的并行和并发执行，提高系统的执行效率和吞吐量。
互斥锁--pthread_mutex
onebutterfly
09-27 4255
互斥锁pthread_mutex pthread_mutex是C语言中在多线程编程中使用的互斥锁，OC中的NSLock等封装的面向对象的锁是对pthread_mutex的封装，常用的API如下 1、初始化锁 pthread_mutex_init(pthread_mutex_t mutex,const pthread_mutexattr_t attr); 初始化一个锁，初始化成功返回零，参数介绍如下 （1）pthread_mutex_t为锁的类型,用于指定互斥锁的属性，有四种类型如下： PTHREAD_
pthread_mutex 互斥锁
tianyexing2008的博客
07-21 2425
互斥锁相信大家都知道其作用了，就是用来排他性的访问共享资源，那也就是说哪个线程抢到了锁那这个线程就可以独占这个共享资源，其他线程只能排队等待了。那互斥锁的用法其实也不复杂，在需要独占访问的资源地方加锁即可。
使用pthread_mutex_t锁的例子
JenponTan 的专栏
11-25 2339
<br />linux下为了多线程同步，通常用到锁的概念。<br />posix下抽象了一个锁类型的结构：ptread_mutex_t。通过对该结构的操作，来判断资源是否可以访问。顾名思义，加锁(lock)后，别人就无法打开，只有当锁没有关闭(unlock)的时候才能访问资源。<br />它主要用如下5个函数进行操作。<br />1：pthread_mutex_init(pthread_mutex_t * mutex,const pthread_mutexattr_t *attr);<br />初始化锁变量
pthread_mutex_t_is_too_small_for_large_pids_in_aosp_bionic.patch
03-13
32位android中bionic是32位的，其中的mutex只有一半也就是16位能够存储pid，当通过docker运行android时，大概率pid会超过16位的范围，就可能会导致android中mutex死锁，表现为应用卡住黑屏。 [32-bit ABI bugs]...
pthread_cond_wait() 用法深入分析
09-05
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; static int data_ready = 0; // 生产者线程 void* producer(void* arg) { // 生产数据... ...
pthread_mutex_init等多线程函数的使用总结
Ataraxia的专栏
09-19 1万+
线程按照其调度者可以分为用户级线程和核心级线程两种 用户级线程主要解决的是上下文切换的问题，它的调度算法和调度过程全部由用户自行选择决定，在运行时不需要特定的内核支持； 我们常用基本就是用户级线程，所以就只总结一下POSIX提供的用户级线程接口； 基本线程操作相关的函数： 1线程的建立结束 2线程的互斥和同步 3使用信号量控制线程 4线程的基本属性配置 基本线程操作：
多线程六——加锁方案三 ：pthread_mutex
M316625387的博客
11-13 1498
一、定义 mutex叫做”互斥锁”，等待锁的线程会处于休眠状态 需要导入头文件#import &amp;amp;lt;pthread.h&amp;amp;gt;
linux互斥锁（pthread_mutex)知识点总结
wei_Embedded_z的博客
05-29 6247
linux互斥锁（pthread_mutex)知识点总结
pthread mutex用法
winstan_wahaha的博客
03-08 756
1. 相关函数API int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr) ---动态创建条件变量 pthread_mutex_lock ---互斥锁上锁 pthread_mutex_unlock ----互斥锁解锁 pthread_cond_wait() / pthread_cond_time
0基础学会 线程同步（互斥锁pthread_mutex）（内附C语言源码）
小石_coding
03-29 2009
0基础学会 线程同步（互斥锁pthread_mutex）（内附C语言源码）
【转】pthread mutex 基本用法
sinolover的专栏
03-07 4273
转自：pthread mutex 基本用法 | feng 言 feng 语 锁是程序中经常需要用到的机制，尤其是多线程的程序中，如果没有锁的帮助，线程间的同 步就会非常麻烦甚至不可能。pthread中提供了mutex互斥量这种锁，在 linux 下经常 用到，以下是pthread_mutex_t的相关函数介绍及简单用法。 相关函数 1 2 3 4 5 6 7 8 9 10 #include <pthread.h> pthread_mutex_t m
pthread_mutex_t 互斥锁
陈贤鹏的博客
10-20 1015
Linux的pthread_mutex_t互斥锁锁住的是临界资源，如果同一个线程调用pthread_mutex_lock之后没有unlock，那么当这个线程再次使用pthread_mutex_lock将会阻塞。 这个跟Windows的事件锁不一样，它锁的是线程，同一个线程可以多次调用锁而不会阻塞。
互斥锁pthread_mutex_t的使用
11-12 147
互斥锁pthread_mutex_t的使用http://hi.baidu.com/cunlin/blog/item/1f9e3f384c6bbeffb211c79c.html　有两种方法创建互斥锁，静态方式和动态方式。POSIX...
pthread mutex 属性
spch2008的专栏
12-02 3376
mutex互斥锁有四种属性，分别是NORMAL， ERRORCHECK， RECURSIVE， DEFAULT。
pthread_mutex练习
03-28
<think>嗯，用户想要找关于pthread_mutex的练习题或示例代码。首先，我得回忆一下pthread库中互斥锁的基本用法和相关函数。用户可能对多线程编程中的同步机制不太熟悉，需要一些基础的例子来理解如何正确使用互斥锁。 首先，我应该提供一个简单的示例，展示如何用pthread_mutex_init初始化互斥锁，以及如何在多个线程中加锁和解锁。比如，一个全局变量被多个线程修改的情况，这时候不加锁会导致数据竞争，结果不正确。通过示例演示正确使用互斥锁后的效果。 然后，用户可能需要更复杂的例子，比如生产者-消费者问题。这时候需要用到互斥锁配合条件变量，这样能展示锁在同步中的实际应用。需要确保示例代码结构清晰，注释详细，方便用户理解。 接下来是练习题部分。题目应该由浅入深，从基本的使用到更复杂的问题。比如，第一个题目可以是简单的多线程累加，不使用锁会出现问题，使用锁后解决。第二个题目可以涉及死锁，让用户思考如何避免。第三个题目可能涉及读者写者问题，这样结合互斥锁和读写锁，扩展用户的知识。 同时，要确保代码示例中的错误检查，比如初始化互斥锁是否成功，加锁和解锁的返回值处理。虽然在实际练习中可能忽略错误处理，但良好的习惯需要培养，所以代码中加入错误检查会更好。 另外，用户提供的引用中有提到pthread_join和pthread_detach，可能在示例代码中创建线程后需要使用pthread_join来等待线程结束，避免主线程提前退出。这点需要注意，确保示例的正确运行。 还需要考虑不同平台下pthread库的支持，比如在Linux下编译需要链接-pthread选项，这点在代码注释中提醒用户，避免编译错误。 最后，总结部分要强调互斥锁的重要性，并建议用户通过实际调试来观察锁的行为，比如注释掉加锁部分后观察结果差异，这样能加深理解。</think>### pthread_mutex 基础示例与练习 #### 基础示例1：全局变量保护 ```c #include <stdio.h> #include <pthread.h> #define THREAD_NUM 5 int counter = 0; pthread_mutex_t mutex; void* thread_func(void* arg) { pthread_mutex_lock(&mutex); // 加锁 for (int i=0; i<10000; i++) { counter++; // 临界区操作 } pthread_mutex_unlock(&mutex); // 解锁 return NULL; } int main() { pthread_t tids[THREAD_NUM]; pthread_mutex_init(&mutex, NULL); // 初始化互斥锁[^2] for (int i=0; i<THREAD_NUM; i++) { pthread_create(&tids[i], NULL, thread_func, NULL); } for (int i=0; i<THREAD_NUM; i++) { pthread_join(tids[i], NULL); // 等待线程结束[^1] } printf("Final counter: %d\n", counter); // 正确输出50000 pthread_mutex_destroy(&mutex); return 0; } ``` #### 基础示例2：生产者-消费者模型 ```c #include <pthread.h> #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int count = 0; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; void* producer(void* arg) { while (1) { pthread_mutex_lock(&mutex); if (count < BUFFER_SIZE) { buffer[count++] = 1; // 生产物品 } pthread_mutex_unlock(&mutex); } } void* consumer(void* arg) { while (1) { pthread_mutex_lock(&mutex); if (count > 0) { buffer[--count] = 0; // 消费物品 } pthread_mutex_unlock(&mutex); } } ``` §§ 1. **线程安全栈实现** 实现一个线程安全的栈结构，包含push/pop操作，要求： - 使用互斥锁保护共享数据 - 处理空栈pop时的阻塞情况 ```c // 框架参考 typedef struct { int* data; int top; pthread_mutex_t lock; } ThreadSafeStack; ``` 2. **死锁场景复现** 编写两个线程互相等待对方释放锁的代码，分析如何通过调整加锁顺序避免死锁： ```c // 线程A pthread_mutex_lock(&mutex1); pthread_mutex_lock(&mutex2); // 线程B pthread_mutex_lock(&mutex2); pthread_mutex_lock(&mutex1); ``` 3. **性能对比实验** 对比使用互斥锁（pthread_mutex）和自旋锁（pthread_spinlock）在不同竞争强度下的性能差异，设计测试方案： - 低竞争（操作间隔1ms） - 高竞争（连续操作） #### 关键知识点 1. 互斥锁必须成对使用，`lock/unlock`必须匹配 2. 可通过`pthread_mutex_trylock`实现非阻塞加锁[^3] 3. 推荐使用`PTHREAD_MUTEX_ERRORCHECK`类型锁帮助调试死锁 4. 编译时需添加`-pthread`参数： ```bash gcc program.c -pthread -o program ``` > 建议调试时注释掉加锁代码观察数据竞争现象，对比有/无锁时的程序行为差异，加深对线程同步的理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值