进程线程。

已于 2023-12-10 22:35:25 修改
阅读量405 收藏 6
点赞数 8
文章标签： c语言
于 2023-12-10 22:24:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64059184/article/details/134894511
版权

1> 使用有名管道，完成两个进程的相互通信

#include <myhead.h>
int main(int argc, const char *argv[])
{
	if(argc!=5)
	{
		puts("输入错误请重新输入");
		return -1;
	}
	pid_t pid=-1;
	pid=fork();
	if(pid>0)
	{
		int wfd=-1;
		if((wfd=open(argv[1],O_WRONLY))==-1)
		{
			perror("open 1 error");
			return -1;
		}	
		int rfd=-1;
		if((rfd=open(argv[3],O_RDONLY))==-1)
		{
			perror("open 3 error");
			return -1;
		}
		char a[10];
		while(1)
		{
			bzero(a,sizeof(a));
			int res=read(rfd,a,sizeof(a));
			if(res<=0)
				break;
			write(wfd,a,res);
		}
		close(wfd);
		close(rfd);
		puts("管道1写入完成");
		wait(NULL);
		puts("管道文件均完成任务");
	}
	else if(pid==0)
	{
		int rfd=-1;
		if((rfd=open(argv[2],O_RDONLY))==-1)
		{
			perror("open 2 error");
			return -1;
		}
		int wfd=-1;
		if((wfd=open(argv[4],O_WRONLY|O_TRUNC))==-1)
		{
			perror("open 4 error");
			return -1;
		}	
		char a[10];
		while(1)
		{
			bzero(a,sizeof(a));
			int res=read(rfd,a,sizeof(a));
			if(res<=0)
				break;
			write(wfd,a,res);
		}
		close(wfd);
		close(rfd);
		puts("管道2读取完成完成");
		exit(0);
	}
	else
	{
		perror("fork error");
		return -1;
	}
	return 0;
}

2> 使用无名管道完成父子进程间的通信

#include <myhead.h>
int main(int argc, const char *argv[])
{
	if(argc!=3)
	{
		puts("请重新输入");
		return -1;
	}
	int pipefd[2]={0};
	if(pipe(pipefd)==-1)
	{
		perror("pipe error");
		return -1;
	}
	printf("p1=%d,p2=%d\n",pipefd[0],pipefd[1]);
	pid_t pid=-1;	
	pid=fork();
	if(pid>0)
	{
		//父进程，向无名管道文件内写入数据
		int fd=-1;
		if((fd=open(argv[1],O_RDONLY))==-1)
		{
			perror("open fd");
			return -1;
		}
		char a[50]="";
		while(1)
		{
			bzero(a,sizeof(a));
			int res=read(fd,a,sizeof(a));
			if(res<=0)
			break;
			write(pipefd[1],a,res);
		}
		close(fd);
		close(pipefd[1]);
		puts("文件输入完成");
		wait(NULL);
		puts("拷贝完成");
	}
	else if(pid==0)
	{
		//子进程，写
		int wfd=-1;
		if((wfd=open(argv[2],O_WRONLY|O_CREAT|O_TRUNC|O_EXCL,0664))==-1)
		{
			if(errno=EEXIST)
			{
				puts("文件已存在，请直接使用");
				wfd=open(argv[2],O_WRONLY|O_TRUNC);
			}
			else
			{
				perror("open wfd");
				return -1;
			}
		}
		char a[60]="";
		while(1)
		{
			bzero(a,sizeof(a));
			int res=read(pipefd[0],a,sizeof(a));
			write(wfd,a,res);
			if(res<sizeof(a))
				break;
		}
		close(wfd);
		close(pipefd[0]);
		puts("文件读取完成");
		exit(EXIT_SUCCESS);
	}
	return 0;
}

3> 使用标准IO完成两个文件的拷贝

#include <myhead.h>
int main(int argc, const char *argv[])
{
	FILE *rfd;
	FILE *wfd;
	if((rfd=fopen("./1.c","r"))==NULL)
	{
		perror("fopen rfd");
		return -1;
	}	
	if((wfd=fopen("./1.txt","w"))==NULL)
	{
		perror("fopen wfd");
		return -1;
	}
	char a[20];
	while(1)
	{
		int res=fread(a,1,sizeof(a),rfd);
		if(res<=0)
			break;
		fwrite(a,1,res,wfd);
	}
	fclose(rfd);
	fclose(wfd);
	puts("拷贝完成");
	return 0;
}

4> 使用文件IO实现两个文件的拷贝

#include <myhead.h>
int main(int argc, const char *argv[])
{
	int rfd=-1;
	int wfd=-1;
	if((rfd=open("./1.c",O_RDONLY))==-1)
	{
		perror("open rfd");
		return -1;
	}
	if((wfd=open("./1.txt",O_WRONLY))==-1)
	{
		perror("open wfd");
		return -1;
	}
	char a[20]="";
	while(1)
	{
		int res=read(rfd,a,sizeof(a));
		if(res<=0)
			break;
		write(wfd,a,res);
	}
	close(rfd);
	close(wfd);
	puts("拷贝完成");
	return 0;
}

5> 使用多进程完成两个文件的拷贝

#include <myhead.h>
int lengh()
{
	int rfd=-1;
	int wfd=-1;
	if((rfd=open("./1.c",O_RDONLY))==-1)
	{
		perror("open rfd");
		return -1;
	}
	if((wfd=open("./1.txt",O_WRONLY|O_CREAT|O_TRUNC,0664))==-1)
	{
		perror("open wfd");
		return -1;
	}
	int len=lseek(rfd,0,SEEK_END);
	return len;
}
int kb(int s,int e)
{
	int rfd=-1;
	int wfd=-1;
	if((rfd=open("./1.c",O_RDONLY))==-1)
	{
		perror("open rfd");
		return -1;
	}
	if((wfd=open("./1.txt",O_WRONLY))==-1)
	{
		perror("open wfd");
		return -1;
	}
	lseek(rfd,s,SEEK_SET);
	lseek(wfd,s,SEEK_SET);
	char a[20];
	int sum=0;
	while(1)
	{
		int res=read(rfd,a,sizeof(a));
		sum+=res;
		if(res<=0||sum>e)
		{
			write(wfd,a,res-(sum-e));
			break;
		}
		write(wfd,a,res);
	}
	close(rfd);
	close(wfd);
}
int main(int argc, const char *argv[])
{
	int len=lengh();
	pid_t pid=-1;
	pid=fork();
	if(pid>0)
	{
		kb(0,len/2);
		puts("父进程拷贝完成");
		wait(NULL);
		puts("拷贝完成");
	}
	else if(pid==0)
	{
		kb(len/2,len-len/2);
		puts("子进程拷贝完成");
		exit(0);
	}
	else
	{
		perror("fork");
		return -1;
	}
	return 0;
}

6> 使用多线程完成两个文件的拷贝

#include <myhead.h>
typedef struct a
{
	int s;
	int e;
}ok;
int lengh()
{
	int rfd=-1;
	int wfd=-1;
	if((rfd=open("./1.c",O_RDONLY))==-1)
	{
		perror("open rfd");
		return -1;
	}
	if((wfd=open("./1.txt",O_WRONLY|O_CREAT|O_TRUNC,0664))==-1)
	{
		perror("open wfd");
		return -1;
	}
	int len=lseek(rfd,0,SEEK_END);
	return len;
}
int kb(int s,int e)
{
	int rfd=-1;
	int wfd=-1;
	if((rfd=open("./1.c",O_RDONLY))==-1)
	{
		perror("open rfd");
		return -1;
	}
	if((wfd=open("./1.txt",O_WRONLY))==-1)
	{
		perror("open wfd");
		return -1;
	}
	lseek(rfd,s,SEEK_SET);
	lseek(wfd,s,SEEK_SET);
	char a[20];
	int sum=0;
	while(1)
	{
		int res=read(rfd,a,sizeof(a));
		sum+=res;
		if(res<=0||sum>e)
		{
			write(wfd,a,res-(sum-e));
			break;
		}
		write(wfd,a,res);
	}
	close(rfd);
	close(wfd);
}
void *task(void *arg)
{
	 ok a=*(ok*)arg;	
	kb(a.s,a.e);
	puts("子线程拷贝完成");
	pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
	int len=lengh();
	ok f1={0,len/2};
	ok f2={len/2,len-len/2};
	pthread_t tid1=-1;
	pthread_create(&tid1,NULL,task,&f1);	
	pthread_t tid2=-1;
	pthread_create(&tid2,NULL,task,&f2);
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	puts("拷贝完成");
	return 0;
}

7> 将互斥锁的案例重新写一遍


#include <myhead.h>
 
pthread_cond_t cond;
pthread_mutex_t mutex;
 
void *task1(void *arg)
{
	int n=5;
	while(n--)
	{
		sleep(1);
		printf("sum+1\n");
		pthread_cond_signal(&cond);
	}
	printf("结束\n");
	pthread_exit(NULL);
}
void *task2(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond,&mutex);
 
		printf("sum-1\n");
		
		pthread_mutex_unlock(&mutex);
		pthread_exit(NULL);
	}
}
 
int main(int argc, const char *argv[])
{
			
	pthread_t tid1,tid2,tid3,tid4,tid5,tid6;
 
	pthread_cond_init(&cond,NULL);
	pthread_mutex_init(&mutex,NULL);
 
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("error\n");
		return -1;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("error\n");
		return -1;
	}
	if(pthread_create(&tid3,NULL,task2,NULL)!=0)
	{
		printf("error\n");
		return -1;
	}
	if(pthread_create(&tid4,NULL,task2,NULL)!=0)
	{
		printf("error\n");
		return -1;
	}
	if(pthread_create(&tid5,NULL,task2,NULL)!=0)
	{
		printf("error\n");
		return -1;
	}
	if(pthread_create(&tid6,NULL,task2,NULL)!=0)
	{
		printf("error\n");
		return -1;
	}
	
	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
}

8> 将无名信号量实现生产者消费者程序重新实现一遍

#include <myhead.h>
 
sem_t sem;
 
void *task1(void *arg)
{
	while(1)
	{
		sleep(1);
		printf("sum+1\n");
		sem_post(&sem);
	}
 
 
}
void *task2(void *arg)
{
	while(1)
	{
		sem_wait(&sem);
		printf("sum-1\n");
	}
 
}
int main(int argc, const char *argv[])
{
 
	pthread_t tid1,tid2;
	sem_init(&sem,0,0);
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("error\n");
		return -1;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("error\n");
		return -1;
	}
 
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	
	sem_destroy(&sem);
	return 0;
}

9> 将条件变量实现生产者消费者程序重新实现一遍

#include <myhead.h>
 
int main(int argc, const char *argv[])
{
	int pipefd[2];
	if(pipe(pipefd)==-1)
	{
		perror("pipe");
		return -1;
	}
 
 
	pid_t pid=fork();
	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 if(pid>0)//父进程
	{
	
		close(pipefd[0]);
		
		char buf[128]="";
		while(1)
		{
			fgets(buf,sizeof(buf),stdin);
			buf[strlen(buf)-1]='\0';
			write(pipefd[1],buf,sizeof(buf));
			
			if(strcmp(buf,"quit")==0)
				break;
		}
		close(pipefd[1]);
	}
	else
	{
		printf("error\n");
		return -1;
	}
	wait(NULL);
	return 0;
}

linklzhl
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
进程线程资料
03-08
进程线程资料进程线程资料进程线程资料进程线程资料进程线程资料
九、进程线程补充-进程线程补充
06-11
进程线程补充
八、进程线程 - 进程线程
06-11
进程线程 进程线程
进程线程作业
07-28
关于线程进程的基础代码，适合初学者。
进程线程结束暂停源码_进程与线程
09-25
进程线程暂停或者进程线程结束或者牛逼嗷嗷牛逼
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 连续区间和(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-14 81
YA 在分析一组数据时，需要统计出有多少个连续区间（包括单个元素）的和大于等于给定的阈值 $x$。现在他将这个任务交给你，请你帮忙计算出满足条件的连续区间的数量。 ### 输入格式 第一行包含两个整数 $n$ 和 $x$，分别表示数组的长度和阈值。 第二行包含 $n$ 个正整数，表示给定的数组。 ### 输出格式 输出一个整数，表示满足条件的连续区间的数量。 ### 样例输入1 ``` 3 7 3 4 7 ``` ### 样例输出1 ``` 4 ``` ###
2024年测风激光雷达行业分析报告.pptx
06-16
行业报告
mapreduce综合应用案例 - 招聘数据清洗.docx
06-16
招聘数据清洗是一个典型的大数据处理任务，可以通过MapReduce来实现高效且可扩展的数据清洗过程。下面是一个简单的招聘数据清洗的MapReduce应用案例： 输入数据准备：将招聘数据集划分为若干个块，每个块包含多条记录。 Map阶段： 每个Map任务负责处理一个数据块。 Map函数解析输入记录，提取关键字段，如职位名称、公司名称、薪资等。 对于每条记录，如果关键字段缺失或格式不正确，可以忽略或标记为错误数据。 输出中间键值对，其中键为职位名称，值为包含相关信息的自定义对象或字符串。 Reduce阶段： 所有Map任务的输出会根据职位名称进行分组。 Reduce函数对每个职位名称的数据进行处理，可以进行去重、合并、计数等操作。 根据需求，可以进一步筛选、过滤数据，如只保留特定行业或薪资范围的职位。 输出最终结果，可以保存为文件或存储到数据库中。 通过以上MapReduce应用，可以高效地清洗大规模的招聘数据，并提供结构化、准确的数据用于后续的分析和决策。此外，由于MapReduce具有良好的容错性和可扩展性，可以处理海量数据并在分布式环境中实现高性能的数据清洗任务。
Springboot+vue学生管理系统源码
06-16
Springboot+vue学生管理系统源码 idea导入后端项目，设置好依赖，运行SystemApplication.java 使用vscode或者hbuilderx等工具打开前端项目，运行即可 另外前端vue页打包成静态资源放到后端里面了，即便不运行前端vue项目也是可以的 如果需要修改，则使用npm run bulid重新打包，生成的前端代码，放到后端代码的resources的static目录下
学习数据结构和算法.zip
最新发布
06-16
大学生数据结构学习笔记和资料大全！
机器视觉课程概要及重点分析
06-16
适用于大学生的课程设计，报告等，包含图像处理等许多基础知识
xp系统安装.net框架包括镜像和.net4.0安装包
06-16
xp系统安装.net框架包括镜像和.net4.0安装包
Java项目-基于Springboot+Vue的铁路订票管理系统的设计与实现（源码+万字LW+部署视频+代码讲解视频+全套软件）
06-16
【基于Springboot+Vue的铁路订票管理系统的设计与实现】高分通过项目，已获导师指导。 本项目是一套基于Springboot+Vue的铁路订票管理系统，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的Java学习者。也可作为课程设计、期末大作业 包含：项目源码、数据库脚本、开发说明文档、部署视频、代码讲解视频、全套软件等，该项目可以直接作为毕设使用。 项目都经过严格调试，确保可以运行！ 项目详情: https://blog.csdn.net/u011832806/article/details/139635957
GoogleCloud2024年数据和AI趋势报告+生成式AI+数据治理
06-16
1. 生成式 AI 的影响 生成式 AI 革命及其对各行各业的颠覆性影响。 数据作为 AI 核心的重要性，以及如何利用数据激活生成式 AI。 企业成功利用生成式 AI 的关键要素：数据质量、安全、负责任的数据使用原则。 2. 五大趋势概览 趋势 1：生成式 AI 将在组织内加快数据洞见的交付 数据洞见民主化趋势，非技术用户使用生成式 AI 获取洞见。 现代 BI 工具与生成式 AI 的结合，提升数据素养和决策能力。 趋势 2：数据和 AI 的角色将变得模糊 数据角色界限模糊，数据分析师和数据科学家职责交叉。 生成式 AI 弥合技能差距，提升数据团队效率。 趋势 3：强有力的数据治理机制是实现 AI 创新的关键 暗数据问题，数据质量和治理的重要性。 趋势 4：运营数据将激发生成式 AI 的潜力 企业对与生成式 AI 集成的数据库的期望。 矢量搜索和矢量数据库在生成式 AI 中的应用。 趋势 5：2024 将是数据平台改造突飞猛进的一年 组织对旧数据库 AI 支持状况的不满意。 旧数据库的问题：技术落后、用户体验不佳、成本高昂。 3. Google Cloud 的帮助
unity贪吃蛇大作战项目游戏源代码
06-16
unity贪吃蛇大作战项目游戏源代码，源码演示视频地址：https://www.bilibili.com/video/BV1u1421C7cn/；unity贪吃蛇大作战项目游戏源代码，源码演示视频地址：https://www.bilibili.com/video/BV1u1421C7cn/；unity贪吃蛇大作战项目游戏源代码，源码演示视频地址：https://www.bilibili.com/video/BV1u1421C7cn/；unity贪吃蛇大作战项目游戏源代码，源码演示视频地址：https://www.bilibili.com/video/BV1u1421C7cn/；unity贪吃蛇大作战项目游戏源代码，源码演示视频地址：https://www.bilibili.com/video/BV1u1421C7cn/；unity贪吃蛇大作战项目游戏源代码，源码演示视频地址：https://www.bilibili.com/video/BV1u1421C7cn/；
数据库管理工具:dbeaver-ce-23.0.1-linux.gtk.aarch64-nojdk.tar.gz
06-16
1.DBeaver是一款通用数据库工具，专为开发人员和数据库管理员设计。 2.DBeaver支持多种数据库系统，包括但不限于MySQL、PostgreSQL、Oracle、DB2、MSSQL、Sybase、Mimer、HSQLDB、Derby、SQLite等，几乎涵盖了市场上所有的主流数据库。 3.支持的操作系统：包括Windows（2000/XP/2003/Vista/7/10/11）、Linux、Mac OS、Solaris、AIX、HPUX等。 4.主要特性： 数据库管理：支持数据库元数据浏览、元数据编辑（包括表、列、键、索引等）、SQL语句和脚本的执行、数据导入导出等。 用户界面：提供图形界面来查看数据库结构、执行SQL查询和脚本、浏览和导出数据，以及处理BLOB/CLOB数据等。用户界面设计简洁明了，易于使用。 高级功能：除了基本的数据库管理功能外，DBeaver还提供了一些高级功能，如数据库版本控制（可与Git、SVN等版本控制系统集成）、数据分析和可视化工具（如图表、统计信息和数据报告）、SQL代码自动补全等。
python的字符界面程序
06-16
这个文件资源包含一系列用 Python 编写的字符界面程序，每个程序文件对应一个独立的功能模块。 这些程序的编写难度从简单到中等不等，大多数程序实现单一功能，适合初学者和中级 Python 开发者编写和学习。它们的应用场景涵盖教育、数据处理、安全监控和用户界面美化等多个领域。这些程序可以作为学习 Python 基础知识和进阶技能的良好示例，也可以作为实际项目的基础模块进行扩展和应用。 九九乘法表：生成并打印九九乘法表，用于数学学习和练习。 斐波那契数列：生成并打印指定长度的斐波那契数列。 文本分词：对输入的文本进行分词处理，常用于自然语言处理任务。 简单密码校验 ：对输入的密码进行基本校验，如长度、字符类型等。 简单密码加密：对输入的密码进行简单加密，如使用哈希算法。 打印彩色字符：在终端中打印带有颜色的字符，用于美化输出。 读取大文本文件;读取并处理大文本文件。 监测安全指标：监测系统或应用的安全指标，并输出相应报告。 显示进度条：在终端中显示操作进度条，提供用户反馈。 命令行程序：实现一个简单的命令行工具，接收用户输入并执行相应操作。
MATRIX KEY 4*4触摸按键模块
06-16
VK36N16I芯片 STM32F103驱动代码
JAVA毕业设计之基于SpringBoot+Vue的乡政府管理系统(springboot+mysql)完整源码.zip
06-16
基于SpringBoot+Vue的乡政府管理系统是一个现代化的Web应用程序，它使用了当今流行的技术栈来实现高效的后端服务和交互式的前端界面。以下是该系统使用的主要技术和功能介绍： 技术栈： SpringBoot：一个快速开发的框架，用于构建独立的、生产级别的Spring应用程序。它简化了配置过程，提供了大量默认配置，使得项目启动和运行更加便捷。 Vue.js：一个渐进式的JavaScript框架，用于构建用户界面。它易于上手，同时能够与其它库或已有项目整合，为开发者提供灵活性。 MySQL：一个关系型数据库管理系统，用于存储和管理数据。它支持标准的SQL语言，并且具有高性能、稳定性和易用性的特点。 功能模块： 用户管理：包括用户注册、登录、权限控制等功能，确保系统的安全性和用户的身份验证。 信息发布：允许管理员发布公告、通知等信息，以便及时传达给相关人员。 文件管理：提供文件上传、下载、删除等功能，方便管理和共享文档资料。 数据统计：对系统中的数据进行统计和分析，生成报表和图表，帮助决策者做出明智的决策。 任务管理：支持任务的创建、分配、跟踪和完成情况的记录，提高工作的效率和协作性。 留言板：提供一个平台供用户之间进行交流和讨论，促进信息共享和问题解决。 日志记录：记录系统的运行情况和用户的操作行为，便于问题的排查和安全审计。 数据备份与恢复：定期备份数据并能够在需要时进行恢复，保障数据的完整性和可靠性。 系统设置：允许管理员对系统的各项参数进行配置和管理，以满足不同场景的需求。 以上是该乡政府管理系统的主要技术和功能介绍。通过这些技术和功能的整合，该系统能够提供高效、安全、便捷的管理服务，满足乡政府的日常工作需求。
python进程线程
09-05
Python中的进程和线程都是用于实现并发执行的机制。进程是操作系统资源分配的基本单位，每个进程都有独立的内存空间，不同进程之间的数据不能直接共享。而线程是进程内的执行单元，多个线程可以共享进程的内存空间。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值