linux互斥锁操作

朱雀 2022-08-09 17:48 137阅读 0赞

在线程实际运行过程中，我们经常需要多个线程保持同步。这时可以用互斥锁来完成任务；互斥锁的使用过程中，主要有pthread\_mutex\_init，pthread\_mutex\_destory，pthread\_mutex\_lock，pthread\_mutex\_unlock这几个函数以完成锁的初始化，锁的销毁，上锁和释放锁操作。

一，锁的创建

锁可以被动态或静态创建，可以用宏PTHREAD\_MUTEX\_INITIALIZER来静态的初始化锁，采用这种方式比较容易理解，互斥锁是pthread\_mutex\_t的结构体，而这个宏是一个结构常量，如下可以完成静态的初始化锁：

pthread\_mutex\_t mutex = PTHREAD\_MUTEX\_INITIALIZER;

另外锁可以用pthread\_mutex\_init函数动态的创建，函数原型如下：

int pthread\_mutex\_init(pthread\_mutex\_t \*mutex, const pthread\_mutexattr\_t \* attr)

二，锁的属性

互斥锁属性可以由pthread\_mutexattr\_init(pthread\_mutexattr\_t \*mattr);来初始化，然后可以调用其他的属性设置方法来设置其属性；

互斥锁的范围：可以指定是该进程与其他进程的同步还是同一进程内不同的线程之间的同步。可以设置为PTHREAD\_PROCESS\_SHARE和PTHREAD\_PROCESS\_PRIVATE。默认是后者，表示进程内使用锁。可以使用int pthread\_mutexattr\_setpshared(pthread\_mutexattr\_t \*mattr, int pshared)

pthread\_mutexattr\_getshared(pthread\_mutexattr\_t \*mattr,int \*pshared)

用来设置与获取锁的范围；

互斥锁的类型：有以下几个取值空间：

PTHREAD\_MUTEX\_TIMED\_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。  
  
　　PTHREAD\_MUTEX\_RECURSIVE\_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。  
  
　　PTHREAD\_MUTEX\_ERRORCHECK\_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD\_MUTEX\_TIMED\_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。  
  
　　PTHREAD\_MUTEX\_ADAPTIVE\_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

可以用  
pthread\_mutexattr\_settype(pthread\_mutexattr\_t \*attr , int type)  
pthread\_mutexattr\_gettype(pthread\_mutexattr\_t \*attr , int \*type)

获取或设置锁的类型。

三，锁的释放

调用pthread\_mutex\_destory之后，可以释放锁占用的资源，但这有一个前提上锁当前是没有被锁的状态。

四，锁操作

对锁的操作主要包括加锁 pthread\_mutex\_lock()、解锁pthread\_mutex\_unlock()和测试加锁 pthread\_mutex\_trylock()三个。

int pthread\_mutex\_lock(pthread\_mutex\_t \*mutex)  
  
　　int pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex)  
  
　　int pthread\_mutex\_trylock(pthread\_mutex\_t \*mutex)  
  
　　pthread\_mutex\_trylock()语义与pthread\_mutex\_lock()类似，不同的是在锁已经被占据时返回EBUSY而不是挂起等待

五，锁的使用

**\[cpp\]**  [view plain][] [copy][view plain]

1.  \#include <pthread.h>  
2.  \#include <stdio.h>  
3.    
4.  pthread\_mutex\_t mutex ;  
5.  **void** \*print\_msg(**void** \*arg)\{  
6.          **int** i=0;  
7.          pthread\_mutex\_lock(&mutex);  
8.          **for**(i=0;i<15;i++)\{  
9.                  printf("output : %d\\n",i);  
10.                 usleep(100);  
11.         \}  
12.         pthread\_mutex\_unlock(&mutex);  
13. \}  
14. **int** main(**int** argc,**char**\*\* argv)\{  
15.         pthread\_t id1;  
16.         pthread\_t id2;  
17.         pthread\_mutex\_init(&mutex,NULL);  
18.         pthread\_create(&id1,NULL,print\_msg,NULL);  
19.         pthread\_create(&id2,NULL,print\_msg,NULL);  
20.         pthread\_join(id1,NULL);  
21.         pthread\_join(id2,NULL);  
22.         pthread\_mutex\_destroy(&mutex);  
23.         **return** 1;  
24. \}

将会一个线程一个线程的执行。

1. 互斥锁创建  
        有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD\_MUTEX\_INITIALIZER来静态初始化互斥锁，方法如下：

pthread\_mutex\_t mutex=PTHREAD\_MUTEX\_INITIALIZER;

在LinuxThreads实现中，pthread\_mutex\_t是一个结构，而PTHREAD\_MUTEX\_INITIALIZER则是一个结构常量。

动态方式是采用pthread\_mutex\_init()函数来初始化互斥锁，API定义如下：

int pthread\_mutex\_init(pthread\_mutex\_t \*mutex, const pthread\_mutexattr\_t \*mutexattr)

其中mutexattr用于指定互斥锁属性（见下），如果为NULL则使用缺省属性。

pthread\_mutex\_destroy ()用于注销一个互斥锁，API定义如下：

int pthread\_mutex\_destroy(pthread\_mutex\_t \*mutex)

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

2． 互斥锁属性

互斥锁的属性在创建锁的时候指定，在LinuxThreads实现中仅有一个锁类型属性，不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。当前（glibc2.2.3,linuxthreads0.9）有四个值可供选择：

\* PTHREAD\_MUTEX\_TIMED\_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。

\* PTHREAD\_MUTEX\_RECURSIVE\_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。

\* PTHREAD\_MUTEX\_ERRORCHECK\_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD\_MUTEX\_TIMED\_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁。

\* PTHREAD\_MUTEX\_ADAPTIVE\_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。

3． 锁操作

锁操作主要包括加锁 pthread\_mutex\_lock()、解锁pthread\_mutex\_unlock()和测试加锁 pthread\_mutex\_trylock()三个，不论哪种类型的锁，都不可能被两个不同的线程同时得到，而必须等待解锁。对于普通锁和适应锁类型，解锁者可以是同进程内任何线程；而检错锁则必须由加锁者解锁才有效，否则返回EPERM；对于嵌套锁，文档和实现要求必须由加锁者解锁，但实验结果表明并没有这种限制，这个不同目前还没有得到解释。在同一进程中的线程，如果加锁后没有解锁，则任何其他线程都无法再获得锁。

int pthread\_mutex\_lock(pthread\_mutex\_t \*mutex)

int pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex)

int pthread\_mutex\_trylock(pthread\_mutex\_t \*mutex)

pthread\_mutex\_trylock()语义与pthread\_mutex\_lock()类似，不同的是在锁已经被占据时返回EBUSY而不是挂起等待。

一、 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);

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!

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*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!

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*consumed3

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*consumeover lock

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*I'mout of pthread\_mutex

productbegin lock

Produced4

productover lock

I'mout of pthread\_mutex

[view plain]: http://blog.csdn.net/zmxiangde_88/article/details/7998458#

linux互斥锁操作

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Linux内核互斥锁--mutex

相关 Linux中线程的互斥锁

相关互斥锁

相关 linux线程同步：互斥锁

相关 Linux线程 -- 互斥锁实践

相关 linux互斥锁操作

相关原子操作信号量自旋锁互斥锁

相关 linux 条件变量互斥锁的实现

相关 Linux线程互斥锁

相关互斥锁