Linux多线程编程-互斥锁

最新推荐文章于 2024-06-04 14:50:57 发布

@Z哥哥

最新推荐文章于 2024-06-04 14:50:57 发布

阅读量262

点赞数

分类专栏： c

c 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

互斥锁

多线程编程中，(多线程编程)可以用互斥锁(也称互斥量)可以用来保护关键代码段，以确保其独占式的访问，这有点像二进制信号量。POSIX互斥锁相关函数主要有以下5个：

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

这些函数第一个参数mutex指向要操作的目标互斥锁，成功时返回0，出错返回错误码

l pthread_mutex_init用于初始化互斥锁，mutexattr用于指定互斥锁的属性，若为NULL，则表示默认属性。除了用这个函数初始化互斥所外，还可以用如下方式初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

l pthread_mutex_destroy用于销毁互斥锁，以释放占用的内核资源，销毁一个已经加锁的互斥锁将导致不可预期的后果

l pthread_mutex_lock以原子操作给一个互斥锁加锁。如果目标互斥锁已经被加锁，则pthread_mutex_lock则被阻塞，直到该互斥锁占有者把它给解锁

l pthread_mutex_trylock和pthread_mutex_lock类似，不过它始终立即返回，而不论被操作的互斥锁是否加锁，是pthread_mutex_lock的非阻塞版本。当目标互斥锁未被加锁时，pthread_mutex_trylock进行加锁操作；否则将返回EBUSY错误码。注意：这里讨论的pthread_mutex_lock和pthread_mutex_trylock是针对普通锁而言的，对于其他类型的锁，这两个加锁函数会有不同的行为

l pthread_mutex_unlock以原子操作方式给一个互斥锁进行解锁操作。如果此时有其他线程正在等待这个互斥锁，则这些线程中的一个将获得它

互斥锁示例程序：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define err_sys(msg) \
do { perror(msg); exit(-1); } while(0)
#define err_exit(msg) \
do { fprintf(stderr, msg); exit(-1); } while(0)
int glab = 1;
void *r1(void *arg)
{
pthread_mutex_t* mutex = (pthread_mutex_t *)arg;
static int cnt = 10;
while(cnt--)
{
pthread_mutex_lock(mutex);
glab++;
printf("I am in r1. cnt = %d\n", glab);
pthread_mutex_unlock(mutex);
sleep(1);
}
return "r1 over";
}
void *r2(void *arg)
{
pthread_mutex_t* mutex = (pthread_mutex_t *)arg;
static int cnt = 10;
while(cnt--)
{
pthread_mutex_lock(mutex);
glab++;
printf("I am in r2. cnt = %d\n", glab);
pthread_mutex_unlock(mutex);
sleep(1);
}
return "r2 over";
}
int main(void)
{
pthread_mutex_t mutex;
pthread_t t1, t2;
char* p1 = NULL;
char* p2 = NULL;
if(pthread_mutex_init(&mutex, NULL) < 0)
err_sys("sem_init error");
pthread_create(&t1, NULL, r1, &mutex);
pthread_create(&t2, NULL, r2, &mutex);
pthread_join(t1, (void **)&p1);
pthread_join(t2, (void **)&p2);
pthread_mutex_destroy(&mutex);
printf("s1: %s\n", p1);
printf("s2: %s\n", p2);
return 0;
}

互斥锁属性

pthread_mutexattr_t结构体定义了一套完整的互斥锁属性。线程库提供了一系列函数来操作pthread_mutexattr_t类型变量，以方便我们获取和设置互斥锁属性。一下是一些主要的函数：

#include <pthread.h>
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr, int *restrict pshared);
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);
int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr, int *restrict type);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);

互斥锁两种常用属性：pshared和type

互斥锁属性pshared指定是否允许跨进程共享互斥锁，其可选值有两个：

l PTHREAD_PROCESS_SHARED。互斥锁可以被跨进程共享。

l PTHREAD_PROCESS_PRIVATE。互斥锁只能被和锁的初始化线程隶属于同一个进程的线程共享。

互斥锁属性type指定互斥锁的类型。Linux支持如下4种类型的互斥锁：

l PTHREAD_MUTEX_NORMAL，普通锁。这是互斥锁默认的类型。当一个线程对一个普通锁加锁以后，其余请求该所的线程将形成一个等待队列，并在该所解锁后按优先级获得它。这种锁类型保证了资源分配的公平性。但这种锁也很容易引发问题：一个线程如果对一个已经加锁的普通锁再次加锁，将引发死锁；对一个已经被其他线程加锁的普通锁解锁，或者对一个已经解锁的普通锁解锁将导致不可预期的后果。

l PTHREAD_MUTEX_ERRORCHECK，检错锁。一个线程如果对一个已经加锁的检错锁再次加锁，则加锁操作返回EDEADLK。对一个已经被其让他线程加锁的检错锁解锁，或者对一个已经解锁的检错锁再次解锁，则检错锁返回EPERM。

l PTHREAM_MUTEX_RECURSIVE，嵌套锁。这种锁允许一个线程在释放锁之前对他加锁而不发生死锁。不过其他线程如果要获得这个锁，则当前锁的拥有者必须执行相应次数的解锁操作。对一个已经被其他线程枷锁的嵌套锁解锁，或者对一个已经解锁的嵌套锁再次解锁，则解锁操作返回EPERM。

l PTHREAD_MUTEX_DEFAULT，默认锁。一个线程如果对一个已经加锁的默认锁再次加锁，或者对一个已经被其他线程加锁的默认锁解锁，或者对一个已经解锁的默认锁再次解锁，将导致不可预期的后果。

使用嵌套锁(PTHREAM_MUTEX_RECURSIVE)程序示例：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
int a = 1;
int b = 1;
pthread_mutex_t mutex;
void *pthread1(void *arg)
{
while(1)
{
if(pthread_mutex_lock(&mutex) != 0)
{
printf("1 error\n");
continue;
}
if(pthread_mutex_lock(&mutex) != 0) /* 此时调用了2次lock操作 */
{
printf("1 error\n");
continue;
}
a++;
b++;
if(a != b)
printf("pthread1: %d, %d\n", a, b);
else
printf("11\n");
pthread_mutex_unlock(&mutex);
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
void *pthread2(void *arg)
{
while(1)
{
if(pthread_mutex_lock(&mutex) != 0)
{
printf("2 error\n");
continue;
}
a++;
b++;
if(a != b)
printf("pthread2: %d, %d\n", a, b);
else
printf("22------------\n");
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
int main(void)
{
pthread_t tid1, tid2;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&mutex, &attr);
pthread_create(&tid1, NULL, pthread1, NULL);
pthread_create(&tid2, NULL, pthread2, NULL);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
pthread_mutex_destroy(&mutex);
return 0;
}

@Z哥哥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Linux多线程编程-互斥锁

互斥锁多线程编程中，(多线程编程)可以用互斥锁(也称互斥量)可以用来保护关键代码段，以确保其独占式的访问，这有点像二进制信号量。POSIX互斥锁相关函数主要有以下5个： #include &lt;pthread.h&gt; int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_m...
复制链接

扫一扫

专栏目录