线程的资源保护机制

最新推荐文章于 2022-07-03 18:08:27 发布
最新推荐文章于 2022-07-03 18:08:27 发布
阅读量396 收藏 5
点赞数
分类专栏： linux 文章标签： pthread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43669302/article/details/105582803
版权

1.互斥锁
互斥锁的使用：
定义锁：pthread_mutex_t mutex
初始化锁:int pthread_mutex_init(&mutex,NULL)
加锁：int pthread_mutex_lock(阻塞加锁)
int pthread_mutex_trylock(在锁被占用时，返回EBUSY，而不是挂起等待)
解锁：int pthread_mutex_unlock(&mutex)
销毁:int pthread_mutex_destroy(&mutex)

**注意：多线程的互斥因为没有使用互斥锁，会导致在一个线程写完11111后跑到另一个线程写33333。使用互斥锁，可以避免这种情况发生。

1）采用全局变量

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

#define N 10000

pthread_mutex_t mutex;  

void* task1(void * arg)
{
	int i = 0;
    int fd = *((int*)arg);

	while(i++ < N){
		pthread_mutex_lock(&mutex);
		write(fd,"11111",5);
		write(fd,"22222\n",6);
		pthread_mutex_unlock(&mutex);
	}
	return NULL;
}

void* task2(void * arg)
{
	int i = 0;
     int fd = *((int*)arg);

		while(i++ < N){
			pthread_mutex_lock(&mutex);
			write(fd,"33333",5);
			write(fd,"44444\n",6);
			pthread_mutex_unlock(&mutex);
		}
		return NULL;
	}


int main(){


	pthread_t tid1,tid2;

	int fd;

	fd = open("/home/ben/c.d/t1.txt",O_RDWR|O_CREAT|O_APPEND,0755);
	if(fd == -1){
		printf("open the file fail");
		exit(1);
	}else{
		printf("open successful!\n");
	}

	pthread_mutex_init(&mutex,NULL);


	if(pthread_create(&tid1,NULL,task1,&fd)){
		perror("pthread_create error!");
		exit(1);
	}
	printf("create thread successful!  tid1=%ld\n",tid1);

	if(pthread_create(&tid2,NULL,task2,&fd) != 0){
		perror("pthread_create error!");
		exit(1);
	}
	printf("create thread successful!tid2=%ld\n",tid2);

	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	printf("main join successful!\n");

    pthread_mutex_destroy(&mutex);
    printf("end...");
    close(fd);
	return 0;
}

2)采用参数传递

用结构体定义的变量叫结构体变量，如：
struct student stu; //定义一个结构体变量stu
这种变量在引用结构体成员时，使用点（.）来操作。

结构体类型也可以定义指针变量，如：
struct student *pstu; //定义一个结构体指针变量pstu
pstu=&stu ; //pstu指针指向stu结构体变量
结构体指针变量在引用成员变量时，使用箭头（->）来操作。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

#define N 10000


typedef struct{
	pthread_mutex_t mutex;
	int fd;
}Msg;

void* task1(void * arg)
{
	Msg * msgp = (Msg*)arg;  //这里的参数是一个指针变量，所有我们定义的结构体变量是指针型的
	int fd = msgp->fd;
	int i = 0;

	while(i++ < N){
		pthread_mutex_lock(&msgp->mutex);
		write(fd,"11111",5);
		write(fd,"22222\n",6);
		pthread_mutex_unlock(&msgp->mutex);
	}
	return NULL;
}

void* task2(void * arg)
{
	Msg * msgp = (Msg*)arg;
	int fd = msgp->fd;
	int i = 0;

		while(i++ < N){
			pthread_mutex_lock(&msgp->mutex);
			write(fd,"33333",5);
			write(fd,"44444\n",6);
			pthread_mutex_unlock(&msgp->mutex);
		}
		return NULL;
	}


int main(){

	int fd = open("/home/ben/c.d/t.txt",O_RDWR|O_CREAT|O_APPEND,0755);
		if(fd == -1){
			printf("open the file fail");
			exit(1);
		}else{
			printf("open successful!\n");
		}
	Msg msg;
	msg.fd = fd;
	pthread_t tid1,tid2;


			fd = open("/home/ben/c.d/t.txt",O_RDWR|O_CREAT|O_APPEND,0755);
			if(fd == -1){
				printf("open the file fail");
				exit(1);
			}else{
				printf("open successful!\n");
			}

			pthread_mutex_init(&msg.mutex,NULL);


	if(pthread_create(&tid1,NULL,task1,&msg)){
		perror("pthread_create error!");
		exit(1);
	}
	printf("create thread successful!  tid1=%ld\n",tid1);

	if(pthread_create(&tid2,NULL,task2,&msg) != 0){
		perror("pthread_create error!");
		exit(1);
	}
	printf("create thread successful!tid2=%ld\n",tid2);

	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	printf("main join successful!\n");

    pthread_mutex_destroy(&msg.mutex);
    printf("end...");
    close(fd);
	return 0;
}

2.线程信号量

使用步骤：
1)声明信号量：可以一起声明多个：sem_t 或 sem[n]
2)初始化信号量：sem_init(&sem,0,1) //第二个参数必须为0，表示这里是线程的信号量，为1表示进程的信号量，但还未实现有bug。
3)P操作：sem_wait(&sem)
4)V操作:sem_post(&sem)
5)删除信号量:sem_destroy(&sem)

加信号量互斥—实现互斥取款

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>

int balance = 10;


 sem_t sem1;

void* task11(void * arg)
{
	while(balance > 0){
		sem_wait(&sem1);
		if(balance > 0){
			printf("task11:before draw money,balance is %d\n",balance);
			balance--;
			printf("task11:after draw money,balance is %d\n",balance);
		}
		sem_post(&sem1);
		sleep(1);
	}
	return NULL;
}

void* task22(void * arg)
{
	while(balance > 0){
		sem_wait(&sem1);
		if(balance > 0){
				printf("task22:before draw money,balance is %d\n",balance);
				balance--;
				printf("task22:after draw money,balance is %d\n",balance);
			}
		sem_post(&sem1);
		sleep(1);
		}
		return NULL;
	}


int main(){

		sem_init(&sem1,0,1);
		pthread_t tid1,tid2;

		int fd;

		fd = open("/home/ben/c.d/t.txt",O_RDWR|O_CREAT|O_APPEND,0755);
		if(fd == -1){
			printf("open the file fail");
			exit(1);
		}else{
			printf("open successful!\n");
		}

		if(pthread_create(&tid1,NULL,task11,&fd)){
			perror("pthread_create error!");
			exit(1);
		}
		printf("create thread successful!  tid1=%ld\n",tid1);

		if(pthread_create(&tid2,NULL,task22,&fd) != 0){
			perror("pthread_create error!");
			exit(1);
		}
		printf("create thread successful!tid2=%ld\n",tid2);

		pthread_join(tid1,NULL);
		pthread_join(tid2,NULL);
		printf("main join successful!\n");

		printf("end...");
		close(fd);
		return 0;
}

加信号量实现同步

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>


 sem_t sem[3];

void* task1(void * arg)
{
	while(1){
		sem_wait(&sem[0]);
		printf("1\n");
		sleep(1);
		sem_post(&sem[1]);
	}
	return NULL;
}

void* task2(void * arg)
{
	while(1){
		sem_wait(&sem[1]);
		printf("2\n");
		sleep(1);
		sem_post(&sem[2]);
		}
		return NULL;
	}

void* task3(void * arg)
{
	while(1){
		sem_wait(&sem[2]);
		printf("3\n");
		sleep(1);
		sem_post(&sem[0]);
		}
		return NULL;
	}

int main(){

		sem_init(&sem[0],0,1);
		sem_init(&sem[1],0,0);
		sem_init(&sem[2],0,0);
		pthread_t tid1,tid2,tid3;


		if(pthread_create(&tid1,NULL,task1,NULL)){
			perror("pthread_create error!");
			exit(1);
		}
		printf("create thread successful! tid1=%ld\n",tid1);

		if(pthread_create(&tid2,NULL,task2,NULL) != 0){
			perror("pthread_create error!");
			exit(1);
		}
		printf("create thread successful! tid2=%ld\n",tid2);

		if(pthread_create(&tid3,NULL,task3,NULL) != 0){
				perror("pthread_create error!");
				exit(1);
			}
			printf("create thread successful! tid3=%ld\n",tid3);

		pthread_join(tid1,NULL);
		pthread_join(tid2,NULL);
		pthread_join(tid3,NULL);
		printf("main join successful!\n");


		return 0;
}

互斥锁与信号量的区别：
Mutex 是一把钥匙，一个人拿了就可以进入一个房间，出来的时候把钥匙交给队列的第一个。
Semaphore是一件可以容纳N人的房间，如果人不满就可以进去，如果人满了，就要等待有人出来。队友N=1的情况，称为binarary semaphore。

Binary semaphore与Mutex的差异：
1.mutex要由获得锁的线程来释放（谁获得谁释放）。而semaphore可以由其他线程释放。
2.初始状态可能不一样：mutex的初始值为1，semaphore可能是0（或者是1)。

互斥信号量+条件变量

例题：有一个盘子，其中最多可以放6个馒头。有若干个生产者不断生产馒头，并放在盘子中，但不能超过6个。如果已经满6个，试图生产的生产者将会等待，直到盘中的馒头少于6个后再生产。同时，有若干个消费者，不断来消费盘中的馒头，盘中馒头不能少于0个。如果已经为0个，试图消费的消费者将会等待，直到盘中的馒头大于0个时再消费。
注：（一个生产者生产时另外一个生产者就不能生产，其他消费者也不能消费，同理一个消费者消费时，另一个消费者不能消费，生产者不能生产）

pthread_cond_wait总和一个互斥锁结合使用。在调用pthread_cond_wait前要先获取锁。pthread_cond_wait函数执行时先自动释放指定的锁，然后等待条件变量的变化。在函数调用返回之前，自动将指定的互斥量重新锁住。
int pthread_cond_signal(pthread_cond_t * cond);
pthread_cond_signal通过条件变量cond发送消息，若多个消息在等待，它只唤醒一个。pthread_cond_broadcast可以唤醒所有。调用pthread_cond_signal后要立刻释放互斥锁，因为pthread_cond_wait的最后一步是要将指定的互斥量重新锁住，如果pthread_cond_signal之后没有释放互斥锁，pthread_cond_wait仍然要阻塞。

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

int n = 0;// 0 <= n <= 6

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait_produce = PTHREAD_COND_INITIALIZER;
pthread_cond_t wait_consume = PTHREAD_COND_INITIALIZER;


void *producer(void * arg){
	while(1){
		char *i = arg;
		pthread_mutex_lock(&mutex); //生产者获得锁
		if(n == 6){
			pthread_cond_wait(&wait_produce,&mutex);//生产者等待生产，并释放锁，进入消费者消费模式
		}
		if(n < 6){
			printf("%s before produce:n = %d\n",i,n);
			n++;
			printf("%s after produce:n = %d\n",i,n);
		}
		pthread_cond_signal(&wait_consume); //唤醒消费者
		pthread_mutex_unlock(&mutex);
	//	usleep(1);
	}
	pthread_exit(NULL);
}
void *comsumer(void * arg){
	while(1){
		char *i = arg;
		pthread_mutex_lock(&mutex); //消费者获得锁
		if(n == 0){
			pthread_cond_signal(&wait_produce); //唤醒生产者
			pthread_cond_wait(&wait_consume,&mutex); //消费者等待消费，并释放锁
		}
		if(n > 0){
			printf("%s before consumer:n = %d\n",i,n);
			n--;
			printf("%s after comsumer:n = %d\n",i,n);
		}
		pthread_mutex_unlock(&mutex); //解锁
//		usleep(1);
	}
	pthread_exit(NULL);
}


int main(){
	pthread_t cid1,cid2;
	pthread_t pid1,pid2;
	if(pthread_create(&cid1,NULL,comsumer,"c1") != 0){
		perror("pthread create c1 error\n");
	}
	if(pthread_create(&cid2,NULL,comsumer,"c2") != 0){
			perror("pthread create c2 error\n");
		}
	if(pthread_create(&pid1,NULL,producer,"p1") != 0){
			perror("pthread create p1 error\n");
		}
	if(pthread_create(&pid2,NULL,producer,"p2") != 0){
			perror("pthread create p2 error\n");
		}

	pthread_join(cid1,NULL);
	pthread_join(cid2,NULL);
	pthread_join(pid1,NULL);
	pthread_join(pid2,NULL);
	//destroy pthread_cond
	pthread_cond_destroy(&wait_produce);
	pthread_cond_destroy(&wait_consume);
	pthread_mutex_destroy(&mutex);

	pthread_exit(NULL);
	printf("main is over!\n");

}
郑广翰
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程——线程安全及实现机制
qq_42583242的博客
08-23 576
多线程——线程安全及实现机制 文章目录多线程——线程安全及实现机制一、线程安全概念二、Java 语言中的线程安全1、不可变2、绝对线程安全3、相对线程安全（重要）4、线程兼容三、线程安全的实现机制1、互斥同步(Synchronized、Reentrantlock)2、非阻塞同步(CAS、原子类)3、无同步方案（ThreadLocal）四、总结 一、线程安全概念 讨论线程安全，需要以多个线程之间存在共享数据访问为前提。因为如果根本不存在多线程，又或者一段代码根本不会与其他线程共享数据，那么从线程安全的角度来看
C#的多线程机制探索
06-06
例如，`lock`关键字用于保护共享资源，确保同一时间只有一个线程能访问： ```csharp object resourceLock = new object(); void ThreadFunction() { lock (resourceLock) { // 临界区，同一时间只能有一个线程...
线程控制和线程资源保护
境界の彼方
08-18 3879
第十五篇 线程控制和线程资源保护1、引言 1)从前面的课程我们知道，每个进程都有自己的进程空间（也称为虚拟内存空间），并且在内核中每 个进程都有属于自己的task_struct进程表项来描述自己，这个表项中包含一个很重要的东西，那 就是虚拟地址与实际物理地址的映射表。 2)每个进程的空间的范围都是0到4G，而且都是自己私有的，进程间的切换，会导致虚拟空间的 切换，需要os+mmu一
Java 多线程安全机制
JackieeeCheng的博客
04-08 9386
什么是多线程安全，java中有哪些机制可以保证线程安全
【多线程】线程安全保护机制
Money、坤的博客
07-03 1135
在JDK中，JAVA语言为了维持顺序内部的顺序化语义，也就是为了保证程序的最终运行结果需要和在单线程严格意义的顺序化环境下执行的结果一致，程序指令的执行顺序有可能和代码的顺序不一致，这个过程就称之为指令的重排序。总结，Lock锁相对synchronized使用更加灵活，它使用锁的策略包括可以一直请求锁，也可以尝试请求锁，可以使用带超时的尝试请求锁，还可以带中断的锁，使用lock更加灵活。你会发现，上述代码在正常情况下应该输出是0，但某些时候会出现和理想结果不一致的情况，此时，就表示线程出现了安全问题。...
保护线程安全的机制
yangxiaozhan_的博客
11-12 682
造成线程不安全的三个方面： 基本条件是出现了共享数据 一般也是因为共享数据出现写的情况（如果只读的话，就不会改变数据的值，一般不会出现问题） 原子性、内存的可见性、代码重排序 1.synchronized（加锁）Java中每个对象都有一个锁叫做监视锁 语法：1.作为方法的修饰符 2.作为代码块 public class SynchronizedDemo{ public sync...
C++多线程编程时的数据保护
09-03
为了保护共享数据，我们需要使用同步机制，确保在任何时候只有一个线程能够访问特定的共享资源。C++11提供了几种同步原语，如互斥量（mutex）、条件变量（condition_variable）和原子类型（atomic）。 1. 互斥量...
多线程 C#多线程 多线程机制
04-11
互斥对象提供了一种更为灵活的同步方式，它可以用来保护全局资源，确保同一时间只有一个线程可以访问。`Mutex.WaitOne()`方法用于获取互斥锁，`Mutex.ReleaseMutex()`用于释放锁。 6. **线程安全问题** 在多线程...
Java多线程同步机制研究分析.pdf
最新发布
12-27
本文通过对Java多线程同步机制的研究和分析，旨在解决多线程中的同步问题和共享资源的访问保护问题。 一、Java多线程同步机制的重要性 Java多线程同步机制是Java编程语言中的一种机制，它允许多个线程同时执行，...
VC多线程编程详解
09-04
线程同步是多线程编程中必须考虑的问题，Win32 API提供了多种同步机制，如事件对象、互斥体、信号量等，防止多个线程对共享资源的竞态条件。 例如，`CreateThread`函数用于创建新线程，参数包括安全属性、栈大小、...
C++ 线程 共享资源保护
04-16 1521
一、C++互斥量 < mutex >头文件介绍 Mutex 系列类(四种) - std::mutex，最基本的 Mutex 类。 - std::recursive_mutex，递归 Mutex 类。 - std::time_mutex，定时 Mutex 类。 - std::recursive_timed_mutex，定时递归 Mutex 类。Lock 类（两种） - 列表内容
Java集合线程保护机制
weixin_47253561的博客
03-22 195
一、验证Collections.synchronizedList（）；线程保护机制 1.创建一个单例//首次运行完、切换a方法中受线程保护和不受线程的代码 /** * * 被调用的类 * @author Ali * */ class A { //单例模式 private static A a = new A(); //隐藏实例 private A() {}; //返回当前 实例 public static A getA(){ return a; } static Lis
线程学习 （四） 线程安全和线程锁机制
JasonHector的博客
11-08 816
线程安全 synchronized lock 锁
工作-离线线程添加保护机制
Clear Code
05-26 291
文章目录离线数据上传线程：添加保护机制策略prune_index_from_head 索引文件裁剪，删除第一个索引添加保护,让出使用权 离线数据上传线程：添加保护机制策略 prune_index_from_head 索引文件裁剪，删除第一个索引 /* attention: 1.当只有1个数据和1个索引头时，数据上传失败，此时不应该删除索引头，故加入(0 == buf)的判断。此时(0 != buf) 2.(0 == buf)时，此时只有索引没有数据，一定要删除索引，否则会导致不
IPC——线程资源保护：互斥锁、信号量、条件变量
weixin_33941350的博客
08-07 259
资源保护 进程的资源保护 对于进程来说，由于每个进程空间是完全独立的，相互间不可能篡改对方进程空间的数据，所以进程空间内部的数据（资源）保护的非常到位，不需要加什么额外的保护机制。只有当它们共享操作第三方资源时才会涉及到资源保护问题，比如共享操作第三方文件（或者共享内存）的数据时，才会使用到进程信号量这样的资源保护机制。我们在讲进程IPC的时候就说过，虽然进程信号量被划到“IPC”中，但是进程...
Java中的线程安全问题
qq_57082071的博客
06-02 227
多个线程处于并行状态并竞争资源时，会出现线程安全问题。所以本篇博客主要介绍了线性安全的相关概念，并提供了几种解决线性安全问题的方法，并对Volatile修饰符做了一定的说明。
多线程之保证线程安全的机制
weixin_45739339的博客
03-20 272
1.Java中提供一种最简单的加锁机制（同步机制） 同步：两个线程之间不再是孤独的了，需要互相考虑对方的情况。 synchronized(同步) 1、作用：就是一把锁，实现两个线程之间互斥 2、语法用法： （1）、作为方法的修饰符，可以写在定义的方法之前 synchronized void 普通方法（）{ } 同步方法 synchronized s...
多线程加入线程锁保护
L888666Q的博客
03-01 713
#include   pthread_mutex_t mut;   //初始化锁 pthread_mutex_init(&mut,NULL);   //加锁 pthread_mutex_lock(&mut); //解锁 pthread_mutex_unlock(&mut);
线程间机制（同步和互斥）
red_rock的博客
09-17 756
线程间机制 { 多线程共享同一个进程子地址空间 优点： 线程间很容易进行通信 1、 通过全局变量实现数据共享和交换 缺点： 多个线程同时访问共享对象时需要引入同步和互斥机制 } 线程的同步和互斥 { 同步 { 同步：指的是多任务（线程）按照约定的顺序相互配合完成一件事情 同步机制基于信号量提出，信号量来决定线程是继续运行还是阻塞等待 P---V操作 信号量是一种受保护
C++多线程竞争 锁机制
05-23
在C++多线程编程中，锁是一种机制，用于控制对共享资源的访问。当多个线程同时读写同一个共享资源时，就会发生竞争条件（race condition）。为了避免这种情况，我们需要使用锁来确保每个线程都能按照预期方式访问...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值