C语言之简单使用互斥锁实现并发控制操作

最新推荐文章于 2024-07-09 15:38:01 发布
最新推荐文章于 2024-07-09 15:38:01 发布
阅读量1.8k 收藏 5
点赞数 1
分类专栏： C 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45492007/article/details/124214922
版权

当前版本：eclipse c++、MinGW-W64-builds-4.3.5、widnwos

1. 声明

当前内容主要为测试使用互斥锁实现并发控制效果，分析C语言中线程并发

2. 不加锁的并发代码

#include <stdio.h>
#include <stdlib.h>
// 从unistd中导入sleep函数
#include<unistd.h>
// 导入需要使用的线程库
#include <pthread.h>
/**
 * 	@description 当前内容主要为测试多线程访问同一个变量的操作，测试并发问题
 * 	@author hy
 * 	@createTime 2022-04-16
 */

void startThread(void *(*run)(void *), void *arg);
int shutdownNum = 3;
static int modifyNum = 0; // 一个全局的共享变量
int defaultSleepTime = 50;
int executeNum = 5;
// 定义互斥锁标记
//pthread_mutex_t lock;

void lockAndIncreament() {
	//pthread_mutex_lock(&lock);
	modifyNum += 1;
	//pthread_mutex_unlock(&lock);
}

// 这里表示一个线程
void* run1(void* arg) {
	char* thread_name = NULL;
	// 校验参数数量和参数个数
	if (!arg || arg <= 0) {
		printf("exit with error!\n");
		shutdownNum--;
		// 将参数的值进行赋值操作
		pthread_exit("arg len <= 0");
	} else {
		thread_name = ((char**) arg)[0];
	}
	int num = 0;
	// 执行特定次打印就结束
	while (num < executeNum) {
		//lockAndIncreament();
		modifyNum+=1;
		++num;
		//pthread_mutex_lock(&lock);
		printf("print %s : modifyNum : %d\n", thread_name, modifyNum);
		//pthread_mutex_unlock(&lock);
		fflush(stdout);
		// 表示使用打印为1秒每次sleep(1);
		sleep(1); //表示休眠200毫秒
	}
	printf("%s exit!\n", thread_name);
	fflush(stdout);
	shutdownNum--;
	pthread_exit("num >5");
	return NULL;
}

void* run2(void* arg) {
	char* thread_name = NULL;
	// 校验参数数量和参数个数
	if (!arg || arg <= 0) {
		printf("exit with error!\n");
		shutdownNum--;
		// 将参数的值进行赋值操作
		pthread_exit("arg len <= 0");
	} else {
		thread_name = ((char**) arg)[0];
	}
	int num = 0;
	// 执行特定次打印就结束
	while (num < executeNum) {
		//lockAndIncreament();
		modifyNum+=1;
		++num;
		//pthread_mutex_lock(&lock);
		printf("print %s : modifyNum : %d\n", thread_name, modifyNum);
		//pthread_mutex_unlock(&lock);
		fflush(stdout);
		// 表示使用打印为1秒每次sleep(1);
		sleep(1); //表示休眠200毫秒
	}
	printf("%s exit!\n", thread_name);
	fflush(stdout);
	shutdownNum--;
	pthread_exit("num >5");
	return NULL;
}
void* run3(void* arg) {
	// 得到当前执行的线程的执行id
	char* thread_name = NULL;
	// 校验参数数量和参数个数
	if (!arg || arg <= 0) {
		printf("exit with error!\n");
		shutdownNum--;
		// 将参数的值进行赋值操作
		pthread_exit("arg len <= 0");
	} else {
		thread_name = ((char**) arg)[0];
	}
	int num = 0;
	// 执行特定次打印就结束
	while (num < executeNum) {
		//lockAndIncreament();
		modifyNum+=1;
		++num;
		//pthread_mutex_lock(&lock);
		printf("print %s : modifyNum : %d\n", thread_name, modifyNum);
		//pthread_mutex_unlock(&lock);
		fflush(stdout);
		// 表示使用打印为1秒每次sleep(1);
		sleep(1); //表示休眠200毫秒
	}
	printf("%s exit!\n", thread_name);
	fflush(stdout);
	shutdownNum--;
	pthread_exit("num >5");
	return NULL;
}

void* run4(void* arg) {

	char* thread_name = NULL;
	// 校验参数数量和参数个数
	if (!arg || arg <= 0) {
		printf("exit with error!\n");
		shutdownNum--;
		// 将参数的值进行赋值操作
		pthread_exit("arg len <= 0");
	} else {
		thread_name = ((char**) arg)[0];
	}
	int num = 0;
	while (num < executeNum) {
		//lockAndIncreament();
		modifyNum+=1;
		++num;
		//pthread_mutex_lock(&lock);
		printf("print %s : modifyNum : %d\n", thread_name, modifyNum);
		//pthread_mutex_unlock(&lock);
		fflush(stdout);
		// 表示使用打印为1秒每次sleep(1);
		sleep(1); //表示休眠200毫秒
	}
	printf("%s exit!\n", thread_name);
	fflush(stdout);
	shutdownNum--;
	pthread_exit("num >5");
	return NULL;
}

int main(int argc, char **argv) {
	void *(*func1)(void *) = run1;
	void *(*func2)(void *) = run2;
	void *(*func3)(void *) = run3;
	void *(*func4)(void *) = run4;
	char* arg1[2] = { "thread-1" };
	void* args1 = arg1; // 使用携带正确参数的可以执行，否则认为不可执行
	printf("before create thread\n");
	char* arg2[2] = { "thread-2" };
	void* args2 = arg2;
	char* arg3[2] = { "thread-3" };
	void* args3 = arg3;
	char* arg4[2] = { "thread-4" };
	void* args4 = arg4;
	// 启动三个线程，执行不同的方法(如果执行的方法相同则不会出现并发？)
	// 解决多线程问题
	// 1. 初始化互斥锁
	//pthread_mutex_init(&lock, NULL);
	startThread(func1, args1);
	startThread(func2, args2);
	startThread(func3, args3);
	startThread(func4, args4);

	//startThread(func1, args1);
	// startThread(func1, args2);
	// startThread(func1, args3);
	printf("after create thread\n");
	while (shutdownNum > 0) {
		//printf("main thread wait! shutdownNum = %d\n",shutdownNum);
		//fflush(stdout);
		sleep(1);
	}
	printf("main thread shutdown!\n");
	printf("modifyNum = %d", modifyNum);
	// 销毁互斥锁
	//pthread_mutex_destroy(&lock);
	return 0;
}
// 表现为启动一个线程，给定一个函数和参数
void startThread(void *(*run)(void *), void *arg) {
	pthread_t th;
	const pthread_attr_t *attr = NULL;
	void *(*func)(void *) = run;
	int result = pthread_create(&th, attr, func, arg);
	if (result != 0) {
		// 表示无法创建该线程
		printf("can't create thread in current application!");
		exit(-1);
	}

	// 表现为join操作，即线程必定阻塞主线程执行，&res表示将返回结果拿到
	//pthread_join(th, res);
}

执行结果(有部分情况下会出现如下效果，多次测试后才会出现)
在这里插入图片描述
并发就是有竞争，导致得到的结果不正确，这里结果应该是20

3. 将锁控制打开后

一般对于竞争的变量加入读保护和写保护就可以了(防止并发中写入或者读取不正确)

#include <stdio.h>
#include <stdlib.h>
// 从unistd中导入sleep函数
#include<unistd.h>
// 导入需要使用的线程库
#include <pthread.h>
/**
 * 	@description 当前内容主要为测试多线程访问同一个变量的操作，测试并发问题
 * 	@author hy
 * 	@createTime 2022-04-16
 */

void startThread(void *(*run)(void *), void *arg);
int shutdownNum = 3;
static int modifyNum = 0; // 一个全局的共享变量
int defaultSleepTime = 50;
int executeNum = 5;
// 定义互斥锁标记
pthread_mutex_t lock;

void lockAndIncreament() {
	pthread_mutex_lock(&lock);
	modifyNum += 1;
	pthread_mutex_unlock(&lock);
}

// 这里表示一个线程
void* run1(void* arg) {
	char* thread_name = NULL;
	// 校验参数数量和参数个数
	if (!arg || arg <= 0) {
		printf("exit with error!\n");
		shutdownNum--;
		// 将参数的值进行赋值操作
		pthread_exit("arg len <= 0");
	} else {
		thread_name = ((char**) arg)[0];
	}
	int num = 0;
	// 执行特定次打印就结束
	while (num < executeNum) {
		lockAndIncreament();
		//modifyNum+=1;
		++num;
		pthread_mutex_lock(&lock);
		printf("print %s : modifyNum : %d\n", thread_name, modifyNum);
		fflush(stdout);
		pthread_mutex_unlock(&lock);
		// 表示使用打印为1秒每次sleep(1);
		sleep(1); //表示休眠200毫秒
	}
	printf("%s exit!\n", thread_name);
	fflush(stdout);
	shutdownNum--;
	pthread_exit("num >5");
	return NULL;
}

void* run2(void* arg) {
	char* thread_name = NULL;
	// 校验参数数量和参数个数
	if (!arg || arg <= 0) {
		printf("exit with error!\n");
		shutdownNum--;
		// 将参数的值进行赋值操作
		pthread_exit("arg len <= 0");
	} else {
		thread_name = ((char**) arg)[0];
	}
	int num = 0;
	// 执行特定次打印就结束
	while (num < executeNum) {
		lockAndIncreament();
		//modifyNum+=1;
		++num;
		pthread_mutex_lock(&lock);
		printf("print %s : modifyNum : %d\n", thread_name, modifyNum);
		fflush(stdout);
		pthread_mutex_unlock(&lock);

		// 表示使用打印为1秒每次sleep(1);
		sleep(1); //表示休眠200毫秒
	}
	printf("%s exit!\n", thread_name);
	fflush(stdout);
	shutdownNum--;
	pthread_exit("num >5");
	return NULL;
}
void* run3(void* arg) {
	// 得到当前执行的线程的执行id
	char* thread_name = NULL;
	// 校验参数数量和参数个数
	if (!arg || arg <= 0) {
		printf("exit with error!\n");
		shutdownNum--;
		// 将参数的值进行赋值操作
		pthread_exit("arg len <= 0");
	} else {
		thread_name = ((char**) arg)[0];
	}
	int num = 0;
	// 执行特定次打印就结束
	while (num < executeNum) {
		lockAndIncreament();
		//modifyNum+=1;
		++num;
		pthread_mutex_lock(&lock);
		printf("print %s : modifyNum : %d\n", thread_name, modifyNum);
		fflush(stdout);
		pthread_mutex_unlock(&lock);

		// 表示使用打印为1秒每次sleep(1);
		sleep(1); //表示休眠200毫秒
	}
	printf("%s exit!\n", thread_name);
	fflush(stdout);
	shutdownNum--;
	pthread_exit("num >5");
	return NULL;
}

void* run4(void* arg) {

	char* thread_name = NULL;
	// 校验参数数量和参数个数
	if (!arg || arg <= 0) {
		printf("exit with error!\n");
		shutdownNum--;
		// 将参数的值进行赋值操作
		pthread_exit("arg len <= 0");
	} else {
		thread_name = ((char**) arg)[0];
	}
	int num = 0;
	while (num < executeNum) {
		lockAndIncreament();
		//modifyNum+=1;
		++num;
		pthread_mutex_lock(&lock);
		printf("print %s : modifyNum : %d\n", thread_name, modifyNum);
		fflush(stdout);
		pthread_mutex_unlock(&lock);

		// 表示使用打印为1秒每次sleep(1);
		sleep(1); //表示休眠200毫秒
	}
	printf("%s exit!\n", thread_name);
	fflush(stdout);
	shutdownNum--;
	pthread_exit("num >5");
	return NULL;
}

int main(int argc, char **argv) {
	void *(*func1)(void *) = run1;
	void *(*func2)(void *) = run2;
	void *(*func3)(void *) = run3;
	void *(*func4)(void *) = run4;
	char* arg1[2] = { "thread-1" };
	void* args1 = arg1; // 使用携带正确参数的可以执行，否则认为不可执行
	printf("before create thread\n");
	char* arg2[2] = { "thread-2" };
	void* args2 = arg2;
	char* arg3[2] = { "thread-3" };
	void* args3 = arg3;
	char* arg4[2] = { "thread-4" };
	void* args4 = arg4;
	// 启动三个线程，执行不同的方法(如果执行的方法相同则不会出现并发？)
	// 解决多线程问题
	// 1. 初始化互斥锁
	pthread_mutex_init(&lock, NULL);
	startThread(func1, args1);
	startThread(func2, args2);
	startThread(func3, args3);
	startThread(func4, args4);

	//startThread(func1, args1);
	// startThread(func1, args2);
	// startThread(func1, args3);
	printf("after create thread\n");
	while (shutdownNum > 0) {
		//printf("main thread wait! shutdownNum = %d\n",shutdownNum);
		//fflush(stdout);
		sleep(1);
	}
	printf("main thread shutdown!\n");
	printf("modifyNum = %d", modifyNum);
	// 销毁互斥锁
	pthread_mutex_destroy(&lock);
	return 0;
}
// 表现为启动一个线程，给定一个函数和参数
void startThread(void *(*run)(void *), void *arg) {
	pthread_t th;
	const pthread_attr_t *attr = NULL;
	void *(*func)(void *) = run;
	int result = pthread_create(&th, attr, func, arg);
	if (result != 0) {
		// 表示无法创建该线程
		printf("can't create thread in current application!");
		exit(-1);
	}

	// 表现为join操作，即线程必定阻塞主线程执行，&res表示将返回结果拿到
	//pthread_join(th, res);
}

多次测试后发现结果是正确的进行了有效的控制
在这里插入图片描述

4. 并发在C中的结论

1.对于c中的线程互斥并发控制需要控制好粒度，注意对于printf和fflush的操作也会导致并发打印出现问题的情况

2. 通过初始化锁、加锁、解锁、销毁锁的操作可以对c中的互斥锁实现控制

3. 一般对于全局的变量的读写操作都是需要加锁的，加锁不正确可能导致结果不正确(多次测试才会出现这个问题)

编程写手
关注
专栏目录
C语言并发控制：信号量与互斥锁的实现与应用
07-28
### C语言并发控制：信号量与互斥锁的实现与应用 #### 一、引言 C语言作为一种经典的编程语言，自20世纪70年代初由丹尼斯·里奇在贝尔实验室开发以来，就因其高效性、灵活性以及强大的硬件控制能力而受到广泛欢迎...
C语言演示互斥锁
qq_43641035的博客
09-03 2736
有共享资源、合作关系的线程之间由于并发交替运行，可能导致运行结果不正常。 下面模拟火车票购票系统，有三个售票窗口同时售票 由于线程的并发执行，导致出现非法的剩余票数。 假设num=1，线程T0进入休眠状态，保护现场后系统调度线程T1，T1休眠调度T2，T2休眠后T0休眠时间到被唤醒并执行num--，T1休眠时间到被唤醒并执行num--，T2休眠时间到被唤醒并执行num-- 加入互斥锁，一个线程在进入临界区时获得锁，其他线程无法进入临界区，在退出临界区时释放锁，其他进程便可
Linux线程-互斥锁pthread_mutex_t
热门推荐
欣宇的专栏
09-20 14万+
在线程实际运行过程中，我们经常需要多个线程保持同步。这时可以用互斥锁来完成任务；互斥锁的使用过程中，主要有pthread_mutex_init，pthread_mutex_destory，pthread_mutex_lock，pthread_mutex_unlock这几个函数以完成锁的初始化，锁的销毁，上锁和释放锁操作。 一，锁的创建     锁可以被动态或静态创建，可以用宏PTHRE
【线程系列之二】线程锁之互斥锁介绍
最新发布
qq_40604302的博客
07-09 1246
公平的互斥量会按照线程请求锁的顺序来授予锁，从而避免了饥饿现象（即某个线程长时间得不到锁的情况）。：互斥量保证在任何时候，只有一个线程可以持有锁并访问受保护的资源。：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。：进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。死锁是指在执行过程中，两个或两个以上的进程或线程由于竞争资源或彼此通信而阻塞，导致无法继续执行的情况。
c语言中锁的作用,c 互斥锁
weixin_29421565的博客
05-16 2714
互斥锁的作用保护共享数据： 在并发机制的情况下，有时候会有多个线程同时访问同一片数据，为了保护数据操作的准确性就需要通过加锁来进行保护。保持操作互斥： 可能一个程序会有多个操作，但是同一个时间只能有一个操作被执行，例如a/b两个操作，如果a被执行,b就不能被执行，同理b被执行，a就不能执行操作函数pthread_mutex_tlock;/*互斥锁定义*/pthread_mutex_init...
C语言多线程互斥锁
junior19的博客
03-04 2万+
互斥锁是为了防止多个线程同时操作临界资源，下面看看用法： # include &lt;stdio.h&gt; # include &lt;pthread.h&gt; pthread_mutex_t mute; int value = 0; void *fun(void *arg){ //上锁，函数是阻塞的 pthread_mutex_lock(&amp;mute); ...
C 语言的 互斥锁、自旋锁、原子操作
m0_37322399的博客
01-07 3607
今天不整，我们来分享一下以前写的，来看看 互斥锁，自旋锁和原子操作的 demo。
C语言实现电梯控制
06-06
6. **同步与通信**：在多线程环境下，电梯之间以及电梯与控制系统之间的通信需要同步机制，比如互斥锁（mutexes）或信号量，以避免数据冲突。 7. **算法设计**：电梯调度算法是项目的关键部分。你可以设计优先级...
3.线程间同步和通信之互斥锁（静态）
08-24
互斥锁在STM32微控制器上使用RT-thread实时操作系统时尤为重要。 首先，我们要理解什么是互斥锁。互斥锁，英文名为Mutex，是一种同步原语，用于保护共享资源不被多个线程同时访问。当一个线程获得了互斥锁，其他...
使用c语言实现一个简单的数据库功能.zip
06-14
在C语言中实现一个简单的数据库功能是一项挑战性的任务，它涉及到数据结构、文件操作和内存管理等多个核心领域。下面将详细介绍这个过程中可能涉及的关键知识点。 首先，我们需要理解数据库的基本概念。数据库是一...
用C语言代码实现GPIO通信协议
05-04
5. **同步机制**：在多线程或多任务环境下，可能需要使用互斥锁或其他同步机制来确保对GPIO的并发访问不会导致数据冲突。 6. **延迟和定时**：在某些应用中，例如脉冲生成或时序控制，可能需要精确的延迟或定时功能...
Mutex（互斥锁）
半月旋空
08-12 1万+
互斥锁(mutex) 在信号量最后的部分说，当count=1的时候可以用信号量实现互斥。在早期的Linux版本中就是当count=1来实现mutex的。 在2.6.11版本中，如下： typedef struct semaphore mutex_t; #define mutex_init(lock, type, name) sema_init(lock, 1) 但是在最新的内核3.18
C语言pthread互斥锁(mutex)和可重入锁(递归锁recursive)的演示
先天无极编程圣体的博客
03-09 1277
1 一旦共享资源被互斥锁锁定,则其余线程想访问共享资源必须等待，直到锁被释放。使用mutex的属性,开启递归锁(可重入锁),解决同一线程可重入问题。2 使用normal属性的互斥锁,一旦发生重入逻辑,则阻塞,成为死锁。需要将属性改为recursive 成为可重入的,递归的。unix-like操作系统 gnu_c或兼容c库。演示未使用可重入锁对资源的重入访问。演示使用互斥锁后 线程的执行顺序。1 命令行传参 1 model=1。2 命令行传参 2 model=2。3 命令行传参 3 model=3。
C语言之简单使用互斥锁、条件锁实现生产者消费者模型操作
编程学习者的博客
04-17 2476
当前版本：eclipse c++、MinGW-W64-builds-4.3.5、widnwos 1. 声明 当前内容主要为使用C语言中的条件锁和互斥锁实现生产者消费者模型，主要参考百度百科 所以使用wait方式时必须要在加锁和解锁范围内，非常类似java中synchronize(lock){wait()}的代码,执行等待必须为线程持有锁 2. 基本demo #include <stdio.h> #include <stdlib.h> // 从unistd中导入sleep函数 #in
C-线程之互斥锁、动态锁、静态锁
qq_44578108的博客
03-20 2453
我们为什么要使用呢？首先，我们需要了解（也就是共享资源）的概念。
c多线程互斥锁
sumengnan的博客
03-24 1415
#include <pthread.h> #include <unistd.h> pthread_mutex_t pthreadMutex; void *testThread(){ printf("线程1开始加锁\n"); pthread_mutex_lock(&pthreadMutex); printf("线程1加锁成功\n"); sleep(10); printf("Hello, World!New Thread11\n"); .
C语言中的并发与同步机制：互斥锁、条件变量、信号量与生产者消费者问题（二）
weixin_56154577的博客
04-07 1287
互斥锁（Mutex）是一种用于实现线程同步的低级原语，它确保在任一时刻，只有一个线程能够访问被互斥锁保护的资源（称为临界区）。互斥锁提供了一种机制，使得多个线程在访问共享资源时，能够按照某种预定的顺序或规则进行访问，避免因并发访问导致的数据不一致或竞态条件。
C语言实现生产者消费者模型(线程、信号量、互斥锁)
weixin_43030270的博客
11-10 2573
C 线程
C语言 线程互斥 互斥锁 示例
YoAron的博客
05-01 851
PTHREAD_MUTEX_ERRORCHECK_NP 检错锁，若同一线程再次请求获取同一锁，返回EDEADLK，其余和普通锁一致。*PTHREAD_MUTEX_RECURSIVE_NP 嵌套锁，同一线程可多次获取同一个锁，并一一解锁，多线程请求会竞争。*PTHREAD_MUTEX_TIMED_NP 普通锁（缺省值），当某一线程获取到锁后，其余线程将形成一个等待队列。*PTHREAD_MUTEX_ADAPTIVE_NP 适应锁，动作最简单的锁，仅等待解锁后重新竞争。返回值：成功 = 0，失败 =!
Unix下C语言实现互斥锁教程
"这篇PPT教程专注于讲解在Unix环境下如何使用C语言创建和管理互斥锁，这是多线程编程中的重要同步机制。互斥锁用于确保同一时间只有一个线程可以访问特定的共享资源，从而避免数据竞争和不一致的情况。 在Unix中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值