Linux应用编程（线程同步）（互斥锁）

最新推荐文章于 2024-05-31 10:53:37 发布

嵌入式学习者。

最新推荐文章于 2024-05-31 10:53:37 发布

阅读量1.3k

点赞数 3

分类专栏： LinuxC编程（文件io，网络编程...）文章标签： linux linux应用开发

本文链接：https://blog.csdn.net/afddasfa/article/details/130351954

版权

LinuxC编程（文件io，网络编程...）专栏收录该内容

34 篇文章 4 订阅

订阅专栏

对于一个单线程进程来说，它不需要处理线程同步的问题，所以线程同步是在多线程环境下可能需要注意的一个问题。线程的主要优势在于，资源的共享性，譬如通过全局变量来实现信息共享，不过这种便捷的共享是有代价的，那就是多个线程并发访问共享数据所导致的数据不一致的问题。

一、为什么需要线程同步？

线程同步是为了对共享资源的访问进行保护。
保护的目的是为了解决数据一致性的问题。
出现数据一致性问题其本质在于进程中的多个线程对共享资源的并发访问（同时访问）。

如下程序：

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

static int g_count = 0;

static void *new_thread_start(void *arg)
{
	 int loops = *((int *)arg);
	 int l_count, j;
	 for (j = 0; j < loops; j++) 
	 {
		 l_count = g_count;
		 l_count++;
		 g_count = l_count;
	 }
	 return (void *)0;
}

static int loops;

int main(int argc, char *argv[])
{
	 pthread_t tid1, tid2;
	 int ret;
	 /* 获取用户传递的参数 */
	 if (2 > argc)
		 loops = 10000000; //没有传递参数默认为 1000 万次
	 else
		 loops = atoi(argv[1]);
	 /* 创建 2 个新线程 */
	 ret = pthread_create(&tid1, NULL, new_thread_start, &loops);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 ret = pthread_create(&tid2, NULL, new_thread_start, &loops);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 
	 /* 等待线程结束 */
	 ret = pthread_join(tid1, NULL);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 ret = pthread_join(tid2, NULL);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 /* 打印结果 */
	 printf("g_count = %d\n", g_count);
	 exit(0);
}

编译代码，进行测试，首先执行代码，传入参数 1000，也就是让每个线程对全局变量 g_count 递增 1000次，如下所示：
在这里插入图片描述
都打印结果看，得到了我们想象中的结果，每个线程递增 1000 次，最后的数值就是 2000；接着我们把递增次数加大，采用默认值 1000 万次，如下所示：
可以发结果竟然不是我们想看到的样子，执行到最后，应该是 2000 万才对。
为了解决上图中数据不一致的问题，就得需要 Linux 提供的一些方法，也就是接下来将要向大家介绍的线程同步技术

从下图中可知，线程 A 和线程 B 都不会同时访问这个变量，当线程 A 需要修改变量的值时，必须等到写操作完成之后（不能打断它的操作），才运行线程 B 去读取。
在这里插入图片描述
线程的主要优势在于，资源的共享性，譬如通过全局变量来实现信息共享。不过这种便捷的共享是有代价的，必须确保多个线程不会同时修改同一变量、或者某一线程不会读取正由其它线程修改的变量，也就是必须确保不会出现对共享资源的并发访问。Linux 系统提供了多种用于实现线程同步的机制，常见的方法有：互斥锁、条件变量、自旋锁以及读写锁等，下面将向大家一一进行介绍。

二、互斥锁

互斥锁（mutex）又叫互斥量，从本质上说是一把锁，在访问共享资源之前对互斥锁进行上锁，在访问完成后释放互斥锁（解锁）；对互斥锁进行上锁之后，任何其它试图再次对互斥锁进行加锁的线程都会被阻塞，直到当前线程释放互斥锁。如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。

1、互斥锁初始化

1.1、使用 PTHREAD_MUTEX_INITIALIZER 宏初始化互斥锁

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

PTHREAD_MUTEX_INITIALIZER 宏已经携带了互斥锁的默认属性。

2、使用 pthread_mutex_init()函数初始化互斥锁

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

函数参数和返回值含义如下：
mutex：参数 mutex 是一个 pthread_mutex_t 类型指针，指向需要进行初始化操作的互斥锁对象；
attr：若将参数 attr 设置为 NULL，则表示将互斥锁的属性设置为默认值，在这种情况下其实就等价于 PTHREAD_MUTEX_INITIALIZER 这种方式初始化，而不同之处在于，使用宏不进行错误检查。
返回值：成功返回 0；失败将返回一个非 0 的错误码。

使用 pthread_mutex_init()函数对互斥锁进行初始化示例：

pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);

或者：

pthread_mutex_t *mutex = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(mutex, NULL);

2.1、互斥锁加锁和解锁

调用函数 pthread_mutex_lock()可以对互斥锁加锁、获取互斥锁，而调用函数 pthread_mutex_unlock()可以对互斥锁解锁、释放互斥锁。其函数原型如下所示：

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

调用 pthread_mutex_unlock()函数将已经处于锁定状态的互斥锁进行解锁。以下行为均属错误：
⚫ 对处于未锁定状态的互斥锁进行解锁操作；
⚫ 解锁由其它线程锁定的互斥锁。

使用示例
使用了一个互斥锁来保护对全局变量 g_count 的访问。

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

static pthread_mutex_t mutex;
static int g_count = 0;

static void *new_thread_start(void *arg)
{
	 int loops = *((int *)arg);
	 int l_count, j;
	 
	 for (j = 0; j < loops; j++) 
	 {
		 pthread_mutex_lock(&mutex); //互斥锁上锁
		 l_count = g_count;
		 l_count++;
		 g_count = l_count;
		 pthread_mutex_unlock(&mutex);//互斥锁解锁
	 }
	 return (void *)0;
}

static int loops;

int main(int argc, char *argv[])
{
	 pthread_t tid1, tid2;
	 int ret;
	 /* 获取用户传递的参数 */
	 if (2 > argc)
		 loops = 10000000; //没有传递参数默认为 1000 万次
	 else
		 loops = atoi(argv[1]);
	 /* 初始化互斥锁 */
	 pthread_mutex_init(&mutex, NULL);
	 /* 创建 2 个新线程 */
	 ret = pthread_create(&tid1, NULL, new_thread_start, &loops);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 ret = pthread_create(&tid2, NULL, new_thread_start, &loops);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 /* 等待线程结束 */
	 ret = pthread_join(tid1, NULL);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 ret = pthread_join(tid2, NULL);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 /* 打印结果 */
	 printf("g_count = %d\n", g_count);
	 exit(0);
}

在这里插入图片描述
可以看到确实得到了我们想看到的正确结果，每次对 g_count 的累加总是能够保持正确，但是在运行程序的过程中，明显会感觉到锁消耗的时间会比较长，这就涉及到性能的问题了，后续会介绍！

2.2、pthread_mutex_trylock()函数

当互斥锁已经被其它线程锁住时，调用 pthread_mutex_lock()函数会被阻塞，直到互斥锁解锁；如果线程不希望被阻塞，可以使用 pthread_mutex_trylock()函数；调用 pthread_mutex_trylock()函数尝试对互斥锁进行加锁，如果互斥锁处于未锁住状态，那么调用 pthread_mutex_trylock()将会锁住互斥锁并立马返回，如果互斥锁已经被其它线程锁住，调用 pthread_mutex_trylock()加锁失败，但不会阻塞，而是返回错误码 EBUSY。

#include <pthread.h>
int pthread_mutex_trylock(pthread_mutex_t *mutex);

参数 mutex 指向目标互斥锁，成功返回 0，失败返回一个非 0 值的错误码，如果目标互斥锁已经被其它线程锁住，则调用失败返回 EBUSY。

使用示例

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

static pthread_mutex_t mutex;
static int g_count = 0;

static void *new_thread_start(void *arg)
{
	 int loops = *((int *)arg);
	 int l_count, j;
	 for (j = 0; j < loops; j++) 
	 {
		 while(pthread_mutex_trylock(&mutex)); //以非阻塞方式上锁
		 l_count = g_count;
		 l_count++;
		 g_count = l_count;
		 pthread_mutex_unlock(&mutex);//互斥锁解锁
	 }
 	 return (void *)0;
}

static int loops;

int main(int argc, char *argv[])
{
	 pthread_t tid1, tid2;
	 int ret;
	 /* 获取用户传递的参数 */
	 if (2 > argc)
	 	loops = 10000000; //没有传递参数默认为 1000 万次
	 else
		 loops = atoi(argv[1]);
	 /* 初始化互斥锁 */
	 pthread_mutex_init(&mutex, NULL);
	 /* 创建 2 个新线程 */
	 ret = pthread_create(&tid1, NULL, new_thread_start, &loops);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 ret = pthread_create(&tid2, NULL, new_thread_start, &loops);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 /* 等待线程结束 */
	 ret = pthread_join(tid1, NULL);
	 if (ret) 
	 {	
		 fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 ret = pthread_join(tid2, NULL);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 /* 打印结果 */
	 printf("g_count = %d\n", g_count);
	 exit(0);
}

整个执行结果跟使用 pthread_mutex_lock()效果是一样的。

2.3、销毁互斥锁

当不再需要互斥锁时，应该将其销毁，通过调用 pthread_mutex_destroy()函数来销毁互斥锁，其函数原型如下所示：

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);

在调用成功情况下返回 0，失败返回一个非 0 值的错误码。
⚫ 不能销毁还没有解锁的互斥锁，否则将会出现错误；
⚫ 没有初始化的互斥锁也不能销毁。
被 pthread_mutex_destroy()销毁之后的互斥锁，就不能再对它进行上锁和解锁了，需要再次调用pthread_mutex_init()对互斥锁进行初始化之后才能使用。

使用示例

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

static pthread_mutex_t mutex;
static int g_count = 0;

static void *new_thread_start(void *arg)
{
	 int loops = *((int *)arg);
	 int l_count, j;
	 for (j = 0; j < loops; j++) 
	 {
		 pthread_mutex_lock(&mutex); //互斥锁上锁
		 l_count = g_count;
		 l_count++;
		 g_count = l_count;
		 pthread_mutex_unlock(&mutex);//互斥锁解锁
	 }
	 return (void *)0;
}

static int loops;

int main(int argc, char *argv[])
{
	 pthread_t tid1, tid2;
	 int ret;
	 /* 获取用户传递的参数 */
	 if (2 > argc)
		 loops = 10000000; //没有传递参数默认为 1000 万次
	 else
		 loops = atoi(argv[1]);
	 /* 初始化互斥锁 */
	 pthread_mutex_init(&mutex, NULL);
	 /* 创建 2 个新线程 */
	 ret = pthread_create(&tid1, NULL, new_thread_start, &loops);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 ret = pthread_create(&tid2, NULL, new_thread_start, &loops);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_create error: %s\n", strerror(ret));
		 exit(-1);
	 }	
	  /* 等待线程结束 */
	 ret = pthread_join(tid1, NULL);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 ret = pthread_join(tid2, NULL);
	 if (ret) 
	 {
		 fprintf(stderr, "pthread_join error: %s\n", strerror(ret));
		 exit(-1);
	 }
	 /* 打印结果 */
	 printf("g_count = %d\n", g_count);
	 /* 销毁互斥锁 */
	 pthread_mutex_destroy(&mutex);
	 exit(0);
}

2.4、互斥锁死锁

试想一下，如果一个线程试图对同一个互斥锁加锁两次，会出现什么情况？情况就是该线程会陷入死锁状态，一直被阻塞永远出不来；这就是出现死锁的一种情况，除此之外，使用互斥锁还有其它很多种方式也能产生死锁。

如下示例代码中所示：

// 线程 A
pthread_mutex_lock(mutex1);
pthread_mutex_lock(mutex2);
// 线程 B
pthread_mutex_lock(mutex2);
pthread_mutex_lock(mutex1);

2.5、互斥锁的属性
当对象不再使用时，需要使用 pthread_mutexattr_destroy()将其销毁，函数原型如下所示：

#include <pthread.h>
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
int pthread_mutexattr_init(pthread_mutexattr_t *attr);

参数 attr 指向需要进行初始化的 pthread_mutexattr_t 对象，调用成功返回 0，失败将返回非 0 值的错误码。
互斥锁的类型属性控制着互斥锁的锁定特性，一共有 4 中类型：

⚫ PTHREAD_MUTEX_NORMAL：一种标准的互斥锁类型，不做任何的错误检查或死锁检测。如果线程试图对已经由自己锁定的互斥锁再次进行加锁，则发生死锁；互斥锁处于未锁定状态，或者已由其它线程锁定，对其解锁会导致不确定结果。
⚫ PTHREAD_MUTEX_ERRORCHECK：此类互斥锁会提供错误检查。譬如这三种情况都会导致返回错误：线程试图对已经由自己锁定的互斥锁再次进行加锁（同一线程对同一互斥锁加锁两次），返回错误；线程对由其它线程锁定的互斥锁进行解锁，返回错误；线程对处于未锁定状态的互斥锁进行解锁，返回错误。这类互斥锁运行起来比较慢，因为它需要做错误检查，不过可将其作为调试工具，以发现程序哪里违反了互斥锁使用的基本原则。
⚫ PTHREAD_MUTEX_RECURSIVE：此类互斥锁允许同一线程在互斥锁解锁之前对该互斥锁进行多次加锁，然后维护互斥锁加锁的次数，把这种互斥锁称为递归互斥锁，但是如果解锁次数不等于加速次数，则是不会释放锁的；所以，如果对一个递归互斥锁加锁两次，然后解锁一次，那么这个互斥锁依然处于锁定状态，对它再次进行解锁之前不会释放该锁。
⚫ PTHREAD_MUTEX_DEFAULT ：此类互斥锁提供默认的行为和特性。使用宏PTHREAD_MUTEX_INITIALIZER 初始化的互斥锁，或者调用参数 arg 为 NULL 的pthread_mutexattr_init()函数所创建的互斥锁，都属于此类型。此类锁意在为互斥锁的实现保留最大灵活性， Linux 上， PTHREAD_MUTEX_DEFAULT 类型互斥锁的行为与PTHREAD_MUTEX_NORMAL 类型相仿。

可以使用 pthread_mutexattr_gettype()函数得到互斥锁的类型属性，使用 pthread_mutexattr_settype()修改

/设置互斥锁类型属性，其函数原型如下所示：
#include <pthread.h>
int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);

而对于 pthread_mutexattr_settype()函数，会将参数 attr 指向的 pthread_mutexattr_t 对象的类型属性设置为参数 type 指定的类型。使用方式如下：

pthread_mutex_t mutex;
pthread_mutexattr_t attr;
/* 初始化互斥锁属性对象 */
pthread_mutexattr_init(&attr);
/* 将类型属性设置为 PTHREAD_MUTEX_NORMAL */
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
/* 初始化互斥锁 */
pthread_mutex_init(&mutex, &attr);
......
/* 使用完之后 */
pthread_mutexattr_destroy(&attr);
pthread_mutex_destroy(&mutex);

嵌入式学习者。

关注

3
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
Linux应用编程（线程同步）（互斥锁）

对于一个单线程进程来说，它不需要处理线程同步的问题，所以线程同步是在多线程环境下可能需要注意的一个问题。线程的主要优势在于，资源的共享性，譬如通过全局变量来实现信息共享，不过这种便捷的共享是有代价的，那就是多个线程并发访问共享数据所导致的数据不一致的问题。
复制链接

扫一扫