IO进程线程2.22

最新推荐文章于 2024-09-13 19:38:44 发布
最新推荐文章于 2024-09-13 19:38:44 发布
阅读量381 收藏 10
点赞数 6
文章标签： c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75442768/article/details/136243773
版权
本文详细介绍了如何使用C语言中的互斥锁、无名信号量、条件变量以及无名和有名管道来实现线程同步和进程间通信，包括任务1和任务2的并发执行，以及多个进程间的通信示例。
摘要由CSDN通过智能技术生成

1、互斥机制代码

#include<myhead.h>

int num =520;             //临界资源

pthread_mutex_t mutex;    //创建一个互斥锁变量

void *task1(void *argc)    //定义任务函数1
{
	printf("111111\n");

	pthread_mutex_lock(&mutex);     //获取锁资源（上锁）
	num=1314;
	sleep(3);
	printf("task1:num=%d\n",num);
	pthread_mutex_unlock(&mutex);     //释放锁资源（解锁）
}

void *task2(void *arg)
{
	printf("2222222\n");

	pthread_mutex_lock(&mutex);     //获取锁资源
	num++;                       
	sleep(1);                  //在休眠时，任务1执行到赋值语句
	printf("task2:num=%d\n",num);    
	pthread_mutex_unlock(&mutex);   //释放锁资源
}
int main(int argc, const char *argv[])
{
	pthread_mutex_init(&mutex,NULL);          //初始化互斥锁

	pthread_t tid1,tid2;             //创建两个线程
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("tid1 create error\n");
		return 0;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("tid2 create error\n");
		return 0;
	}
	printf("tid1:%#lx,tid2:%#lx\n",tid1,tid2);
	pthread_join(tid1,NULL);                   //回收线程资源
	pthread_join(tid2,NULL);
	pthread_mutex_destroy(&mutex);          //销毁锁资源
	return 0;
}

2、无名信号量代码

#include<myhead.h>

sem_t sem;           //创建无名信号量

void * task1(void *arg)    //定义生产者线程
{
	int num =5;
	while(num--)
	{
		sleep(1);
		printf("我生产了一辆特斯拉\n");
		sem_post(&sem);                   //释放资源
	}
	pthread_exit(NULL);
}

void *task2(void *arg)         //定义消费者线程
{
	int num =5;
	while(num--)
	{
		sem_wait(&sem);               //申请资源，task1释放的资源被task2申请
		printf("我消费了一辆特斯拉\n");
	}
	pthread_exit(NULL);

}

int main(int argc, const char *argv[])
{
	sem_init(&sem,0,0);           //初始化无名信号量
    //第一个0：表示用于线程的同步
    //第二个0：表示初始资源为0


	pthread_t tid1,tid2;          //创建2个线程，生产者和消费者
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("tid1 create error\n");
		return 0;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("tid2 create error\n");
		return 0;
	}
	printf("tid1: %#lx,tid2: %#lx\n",tid1,tid2);

	pthread_join(tid1,NULL);     //回收县线程资源
	pthread_join(tid2,NULL);      

	sem_destroy(&sem);            //释放无名信号量
	return 0;
}

创建3个线程，线程1打印输出字符A，线程2打印输出字符B，线程3打印输出字符C，用无名信号量实现输出结果为：ABCABCABCABCABC

#include<myhead.h>

sem_t sem1,sem2,sem3;        //创建无名信号量

void *task1(void *arg)         //定义线程1
{  int n=5;
   while(n--)
   {    
        sem_wait(&sem1);
	    sleep(1);
   		printf("A");
                fflush(stdout);           //清空输出缓冲区
		sem_post(&sem2);
   }
   pthread_exit(NULL);                 //结束线程
}
void *task2(void *arg)         //定义线程2
{   int n=5;
	while(n--)
	{   
	  	sem_wait(&sem2);
        sleep(1);            
		printf("B");
              fflush(stdout); 
       	sem_post(&sem3);
	}
	pthread_exit(NULL);
}
void *task3(void *arg)
{   int n=5;
	while(n--)
	{
		sem_wait(&sem3);
        sleep(1);
		printf("C");
        fflush(stdout);
		sem_post(&sem1);
	}
	pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
	sem_init(&sem1,0,1);
	sem_init(&sem2,0,0);
	sem_init(&sem3,0,0);
	pthread_t tid1,tid2,tid3;
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("tid1 create error\n");
		return 0;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("tid2 create error\n");
		return 0;
	}
	if(pthread_create(&tid3,NULL,task3,NULL)!=0)
	{
		printf("tid3 create error\n");
		return 0;
	}
 	printf("tid1:%#lx,tid2:%#lx,tid3:%#lx\n",tid1,tid2,tid3);
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_join(tid3,NULL);
	sem_destroy(&sem1);
	sem_destroy(&sem2);
	sem_destroy(&sem3);
	return 0;
}

3、条件变量代码

#include<myhead.h>

pthread_cond_t cond;             //定义条件变量

pthread_mutex_t mutex;            //定义互斥锁变量

void *task1(void *arg)           //定义生产者线程
{
	int num =5;
	while(num--)
	{
		sleep(1);
		printf("%#lx:生产了一台特斯拉\n",pthread_self());

		pthread_cond_signal(&cond);       //唤醒一个消费者
	}
    //或者在这里加pthread_cond_broadcast(&cond), 上面的signal就可要可不要
	pthread_exit(NULL);
}

void *task2(void *arg)               //定义消费者队列
{
	pthread_mutex_lock(&mutex);       //获取锁资源

	pthread_cond_wait(&cond,&mutex);    //进入等待队列
    

	printf("%#lx:消费了一辆特斯拉\n",pthread_self());
	pthread_mutex_unlock(&mutex);
	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
	pthread_cond_init(&cond,NULL);
	pthread_mutex_init(&mutex,NULL);
	pthread_t tid1,tid2,tid3,tid4,tid5,tid6;
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("tid1 create error\n")	;
		return 0;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("tid2 create error\n")	;
		return 0;
	}
	if(pthread_create(&tid3,NULL,task2,NULL)!=0)
	{
		printf("tid3 create error\n")	;
		return 0;
	}
	if(pthread_create(&tid4,NULL,task2,NULL)!=0)
	{
		printf("tid4 create error\n")	;
		return 0;
	}
	if(pthread_create(&tid5,NULL,task2,NULL)!=0)
	{
		printf("tid5 create error\n")	;
		return 0;
	}
	if(pthread_create(&tid6,NULL,task2,NULL)!=0)
	{
		printf("tid6 create error\n")	;
		return 0;
	}
	
	printf("tid1:%#lx,tid2:%#lx,tid3:%#lx,tid4:%#lx,tid5:%#lx,tid6:%#lx",tid1,tid2,tid3,tid4,tid5,tid6);
    printf("\n");
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_join(tid3,NULL);
	pthread_join(tid4,NULL);
	pthread_join(tid5,NULL);
	pthread_join(tid6,NULL);

	pthread_cond_destroy(&cond);
	pthread_mutex_destroy(&mutex);
	return 0;

}

4、无名管道代码

#include<myhead.h>
int main(int argc, const char *argv[])
{
	int pipefd[2]={0};
	if(pipe(pipefd)==-1)
	{
		perror("pipe error");
		return -1;
	}
	printf("pipefd[0]=%d,pipefd[1]=%d\n",pipefd[0],pipefd[1]);

	pid_t pid=fork();
	if(pid>0)
	{
		close(pipefd[0]);                        //关闭管道读端
		char wbuf[128]="";
		while(1)
		{
			bzero(wbuf,sizeof(wbuf));

			fgets(wbuf,sizeof(wbuf),stdin);
			wbuf[strlen(wbuf)-1]=0;

			//将数据写入管道文件
			write(pipefd[1],wbuf,strlen(wbuf));

			//对写入的数据进行判断
			if(strcmp(wbuf,"quit")==0)
			{
				break;
			}
		}

		close(pipefd[1]);             //关闭写端
		wait(NULL);       //阻塞回收子进程资源
	}else if(pid==0)
	{    //子进程
		close(pipefd[1]);
		char rbuf[128]="";
		while(1)
		{
			bzero(rbuf,sizeof(rbuf));

			read(pipefd[0],rbuf,sizeof(rbuf));

			printf("父进程传来的数据为：%s\n",rbuf);

			if(strcmp(rbuf,"quit")==0)
			{
				break;
			}
		}
		close(pipefd[0]);
		exit(EXIT_SUCCESS);
	}else
	{
		perror("fork error");
		return -1;
	}
	return 0;
}

5、有名管道代码

create.c文件

#include<myhead.h>
int main(int argc, const char *argv[])
{
	if(mkfifo("./myfifo",0664)==-1) //创建一个管道文件
	{
		perror("mkfifo error");
		return -1;
	}
	getchar();   //阻塞
	system("rm myfifo");
	return 0;
}

send.c文件

#include<myhead.h>
int main(int argc, const char *argv[])
{
	int wfd =-1;              //打开管道文件

	if((wfd=open("./myfifo",O_WRONLY))==-1)//以只写的形式打开文件
	{
		perror("open error");
		return -1;
	}
    
	//定义容器
	char wbuf[128]="";
	while(1)
	{
		printf("请输入>>>");
		fgets(wbuf,sizeof(wbuf),stdin);
		wbuf[strlen(wbuf)-1]=0;
                                         
		write(wfd,wbuf,strlen(wbuf)); //将数据写入管道

		if(strcmp(wbuf,"quit")==0)   //判断结果
		{
			break;
		}
	}
	close(wfd);
	return 0;
}

rec.c文件

#include<myhead.h>
int main(int argc, const char *argv[])
{
	int rfd=-1;       //打开管道文件
    if((rfd = open("./myfifo",O_RDONLY))==-1) //以只写形式打开文件
	{
		perror("open error");
		return -1;
	}

    char rbuf[128]="";   //定义容器
    while(1)
	{
		bzero(rbuf,sizeof(rbuf));    //清空数组

		read(rfd,rbuf,sizeof(rbuf));    //读取管道中的数据

		printf("收到的数据为：%s\n",rbuf);//输出结果

		if(strcmp(rbuf,"quit")==0)//判断结果
		{
			break;
		}
	}
	close(rfd);
	return 0;
}

6、使用有名管道完成两个进程的相互通信（可以用多进程或者多线程）

create.c

#include<myhead.h>
int main(int argc, const char *argv[])
{
	if(mkfifo("./myfifo1",0664)==-1) //创建一个管道文件
	{
		perror("mkfifo1 error");
		return -1;
	}
	if(mkfifo("./myfifo2",0664)==-1)
	{
		perror("mkfifo2 error");
		return -1;
	}
	getchar();   //阻塞
	system("rm myfifo1");
	system("rm myfifo2");
	return 0;
}

send.c

#include<myhead.h>
int main(int argc, const char *argv[])
{
	pid_t pid =fork();     //创建一个进程

	if(pid>0)
	{                       //父进程发送数据
		int wfd=-1;         //打开管道文件
		if((wfd=open("./myfifo1",O_WRONLY))==-1)//以只写的形式打开文件
		{
			perror("open error");
			return -1;
		}
	
   
	//定义容器
		char wbuf[128]="";
		while(1)
		{
			printf("请输入>>>");
			fgets(wbuf,sizeof(wbuf),stdin);  //终端输入数据
			wbuf[strlen(wbuf)-1]=0;
                                         
			write(wfd,wbuf,strlen(wbuf)); //将数据写入管道

			if(strcmp(wbuf,"quit")==0)   //结束条件
			{
				break;
			}
		}
	close(wfd);
	}else if(pid==0)
	{
		int rfd =-1;

		if((rfd=open("./myfifo2",O_RDONLY))==-1)
		{
			perror("open error");
			return -1;
		}
		char rbuf[128]="";
		while(1)
		{
			bzero(rbuf,sizeof(rbuf));

			read(rfd,rbuf,sizeof(rbuf));

			printf("收到的数据为：%s\n",rbuf);

			if(strcmp(rbuf,"quit")==0)
			{
				break;
			}
		}
		close(rfd);
	}else
	{
		perror("pid error");
		return -1;
		
	}
	return 0;
}

rec.c

#include<myhead.h>
int main(int argc, const char *argv[])
{
	pid_t pid=fork();
    if(pid>0)
	{     					//父进程
		int rfd=-1;      //打开管道文件

		if((rfd=open("./myfifo1",O_RDONLY))==-1)//只读形式打开文件
		{
			perror("open error");
			return -1;
		}
		char rbuf[128]="";
		while(1)
		{
			bzero(rbuf,sizeof(rbuf));// 清空数组

			read(rfd,rbuf,sizeof(rbuf)); //从管道读取数据

			printf("收到数据为:%s\n",rbuf);
			if(strcmp(rbuf,"quit")==0)  //退出条件
			{
				break;
			}
		}
		close(rfd);
	}else if(pid==0)
	{  							//子进程
		int wfd =-1;  			//打开管道文件
		if((wfd=open("./myfifo2",O_WRONLY))==-1)//只写形式打开文件
		{
			perror("open error");
			return -1;
		}

		char wbuf[128]="";
		while(1)
		{
			printf("请输入：");
			fgets(wbuf,sizeof(wbuf),stdin);//从终端输入数据
			wbuf[strlen(wbuf)-1]=0;

			write(wfd,wbuf,strlen(wbuf));//写入管道文件

			if(strcmp(wbuf,"quit")==0)
			{
				break;
			}
		}
		close(wfd);
	}else
	{
		perror("pid error");
		return -1;
	}

	return 0;
}

create.c结束之后，另外两个也用不了

思维导图

Wzp3487
关注
C++多线程编程(一)：互斥锁
追寻梦想的青春
01-15 1940
在现代程序开发中，会大量使用多线程机制，很多语言都内置了对多线程的支持，而C++直到C++11才提供了对多线程的支持，既然支持多线程，那么一定也提供了锁的支持。为什么多线程就一定用锁呢？因为当程序以多线程运行时，如果有对共享资源的使用，例如，两个线程同时对共享变量进行修改，由于这些操作不是原子操作，就会导致出现异常情况，修改的两个线程都认为操作成功了，但是实际上只有一个成功了。这时就需要锁去保证两个操作都分别执行完成。因此，使用锁就需要搞清楚要保护的共享资源。
进程与线程(下)（操作系统）
French_Riviera的博客
10-21 109
还有一个问题需要我们思考，如果我们将代码中两个进程的两个P操作交换位置，也就是将临界区上锁的P操作与消耗一个资源的P操作进行交换，我们来看一下效果：首先生产者给临界区上锁，但如果此时缓冲区已满，那么生产者就会被卡在P(empty)这个代码处无法继续运行，需要等待消费者生产一个空位才行，但是此时我们再看消费者进程，由于生产者给临界区上锁，导致消费者进程也无法执行，那这样就发生了生产者在等待消费者生产一个空位，而消费者又在等待生产者给临界区解锁，哦豁，发生了死锁问题。那么如果可以剥夺，自然也就没有了死锁。
C语言中的信号量、进程同步与互斥、线程同步与互斥详解
最新发布
weixin_65477256的博客
09-13 1362
在C语言中，信号量是一种用于多线程或进程同步的机制，主要用于解决并发问题，确保多个线程或进程对共享资源的正确访问。它在多进程和多线程编程中扮演重要角色，能有效防止竞态条件和数据不一致。此外，多线程和多进程编程中的同步与互斥问题也是并发编程中必须面对的核心挑战。本文将详细介绍信号量及其应用，并展示如何通过信号量、互斥锁、条件变量等机制进行线程和进程间的同步与互斥。
Linux 进程控制与进程互斥（附源代码）（附实验报告）
03-07
1、利用fork函数创建新进程，并根据fork函数的返回值，判断自己是处于父进程还是子进程中； 2、在新创建的子进程中，使用exec类的函数启动另一程序的执行；分析多进程时系统的运行状态和输出结果； 3、利用最常用的三个函数pthread_create，pthread_join和pthread_exit编写了一个最简单的多线程程序。理解多线程的运行和输出情况； 4、利用信号量机制控制多线程的运行顺序，并实现多线程中数据的共享； 5、分析Linux系统下多进程与多线程中的区别。
进程互斥的概念 与 如何实现进程互斥（代码实例）
卜及中的博客
07-28 397
进程互斥是并发编程中确保安全访问共享资源的重要机制，通过适当的同步工具（如信号量、锁、自旋锁等）可以有效地避免竞态条件，保证系统的稳定性和数据的一致性。
进程互斥以及进程互斥实现方法（包含代码）
m0_58323186的博客
11-25 1117
算法思想：两个进程在访问完临界区之后会把使用临界区的权限交给另一个进程，每个进程进入临界区的权限只能由另一个进程赋予。单标志法的主要问题是违反了空闲让进的原则，当进程0一直不访问临界区，则进程0也无法访问所以违反了空闲让进的原则。缺点：违反了忙则等待的原则。算法思想：设计布尔型的数组，数组中各个元素用来标记进程想进入临界区的意愿。双标志后检查法：双标志后检查法的改版，先上锁后检查，代码如下图。访问临界区的原则:空闲让进，忙则等待，有限等待，让权等待.临界资源：一个时间段内只允许一个进程进行访问的资源。
记录一次进程重启排查过程
_bigfish的博客
01-29 535
问题现象 遇到一个问题，系统有一个进程半夜重启，但是没有发现core文件，只在日志内看到以下信息。 [814931.140133] xxxx[4601]: segfault at 7fb8a77fea18 ip 0000003689207ef0 sp 00007fffaef50ca0 error 4 in libpthread.so.0[3689200000+17000] 排查步骤 内核代码 , arch/x86/include/asm/traps.h * Page fault error code b
多线程之线程实现和状态
qq_60501861的博客
08-30 222
多任务： 同时做多件事情（一遍看电视一遍吃饭）；不过，看起来是多个任务同时在做，其实本质上我们的大脑在同一时间依旧是只做了一件事（速度太快了） 多线程： 高速收费口，只有一个收费口，车太多了会导致排队堵塞，通过效率太低了；为了解决堵塞，又新开了多个收费口，可以同时缴费通过。 进程(Process): 执行程序的一次执行过程，动态概念 包含若干个线程，至少一个。操作系统中运行的程序就是进程比如：QQ，播放器，游戏，IDE…；普通方法调用和多线程示例图 Process 进程 和 Thread 线程 说起进
【C/C++】Linux多进程开发
love_boke的博客
04-02 2030
提示：这里可以添加本文要记录的大概内容：提示：以下是本篇文章正文内容，下面案例可供参考并行与并发01 /进程间通讯概念◼ 进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。◼ 但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信( **IPC：Inter Processes Communication** )。
Java多线程和JUC
m0_51380540的博客
04-07 258
多线程和JUC
Linux驱动开发-proc接口介绍
03-07 1069
与其它常见的文件系统不同的是，/proc是一种伪文件系统（也即虚拟文件系统），存储的是当前内核运行状态的一系列特殊文件，用户可以通过这些文件查看有关系统硬件及当前正在运行进程的信息，甚至可以通过更改其中某些文件来改变内核的运行状态。
进程同步与互斥：System V 信号量示例代码
08-20
进程同步与互斥：System V 信号量，相关使用教程链接如下： http://blog.csdn.net/tennysonsky/article/details/47811201
编程实现进程（线程）同步和互斥
11-25
在Windows等操作系统下，使用的VC、VB、java或C等编程语言，采用进程（线程）同步和互斥的技术编写程序实现生产者-消费者问题或哲学家进餐问题或读者-写者问题或自己设计一个简单进程（线程）同步和互斥的实际问题。
C例子：进程互斥
12-22
该程序是我写的博客“一起talk C栗子吧（第八十回：C语言实例--进程互斥）”的配套程序，共享给大家使用
进程同步与互斥
weixin_44057219的博客
12-15 670
并发性，异步性，独立性 以进程QQ和Chrome的伪代码为例: QQ() Chrome() { { while(1) while(1) { { c=a+b; (1) x=y+z; (1) b=a+c; (2) y=x*z; (2) a=c+b; (3) if(x==y) (3) if(a==b) { { z+=y; c
进程同步与互斥——相关问题汇总（源码+伪代码）
CLZHIT的博客
02-15 8273
问题描述： 某博物馆最多可容纳500人同时参观，有一个出入口，该出入口一次仅允许一个人通过。参观者的活动描述如下： cobegin 参观者进程i: { //进门 //参观 //出门 } coend 请添加必要的信号量和P、V（或wait()、signal()）操作，以实现上述过程中的互斥与同步。要求写出完整的过程，说明信号量的含义并赋初值。 问题分析： //错误的解法，该题中提到了只有一个出入口，就是只有一个门，可以是出，也可以入，每次只能一个人过 semaphore out = 1; semaph
【操作系统】进程互斥的实现
daixd5520的博客
03-22 1118
三个管理原则: 互斥性 进展性 有限等待性 两个进程互斥相关的算法 尝试1:给进程一个turn值.按号进入 代码: int turn; P0: do{ while(turn==1);//turn只要为1就一直循环,叫做"Busy Waiting"状态,不进入等待状态,只是忙式等待 /*此处写临界区代码*/ turn=1;//turn一开始为0.所以P0进入临界区,执行完将turn置1,P1就可以退出循环进入临界区了 /*此处写其余代码*/ }while(1); P1: do{ while(t
操作系统 进程同步与互斥 C++代码模拟实现
qq_52788258的博客
09-04 2424
操作系统 进程同步与互斥 C++代码模拟实现，模拟完成哲学家就餐问题
理解IO与线程进程：标准IO库和缓冲机制
"IO与线程进程" 在计算机科学中，IO（Input/Output）是指程序与外部设备（如硬盘、键盘、显示器等）之间交换数据的过程。线程和进程则是操作系统中并行处理任务的基本单位。理解IO和线程进程的关系对于编写高效、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值