实验3 进程之间的通信

最新推荐文章于 2024-05-24 12:24:12 发布
最新推荐文章于 2024-05-24 12:24:12 发布
阅读量2.9k 收藏 65
点赞数 10
分类专栏： Linux实验 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46036214/article/details/110569649
版权

title: 实验3 进程之间的通信
date: 2020-12-03 20:09:11
tags:

实验3 进程之间的通信

题目一

编写程序实现以下功能：

  1. 利用匿名管道实现父子进程间通信，要求

  2. 父进程发送字符串“hello child”给子进程；

  3. 子进程收到父进程发送的数据后，给父进程回复“hello farther”；

  4. 父子进程通信完毕，父进程依次打印子进程的退出状态以及子进程的pid。

    #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
	int fd1[2],fd2[2];
	pipe(fd1);
	pipe(fd2);

	int pid;
	pid = fork();

	if(pid < 0)
		perror("fork");
	else if(pid == 0) {
		close(fd1[0]);
		close(fd2[1]);
		char str[12];
		printf("This is the child!\n");

		if(read(fd2[0],str,12) > 0) {
			printf("Received the news: %s\n",str);
			if(write(fd1[1],"hello father",12) < 0)
				perror("write");
		} else
			perror("read");

		exit(5);
	} else {
		int status;
		printf("This is the father!\n");

		close(fd1[1]);
		close(fd2[0]);

		char buf[24] = "hello child";
		if(write(fd2[1],buf,12) < 0)
			perror("write");
		else {
			printf("Send news successful!\n");
		}

		wait(&status);
		if(WIFEXITED(status)) {
			printf("The child's pid is: %d\n",pid);
			printf("The child's exited status is: %d\n",WEXITSTATUS(status));
		}
	}

	return 0;
}

    运行截图

    1

    结果分析

    ​ 管道作为较为原始的进程间的通信方式，在进程间的通信中被广泛使用。管道可分为有名管道和匿名管道，两者有相似之处又有一定的区别。

    匿名管道的特点如下：

    1.匿名管道是半双工的，数据只能朝一个放向流动，因此要实现两个进程的通信，就必须建立两个匿名管道；

    2.匿名管道只能在管道尾部写入数据，从管道头部读取数据；fd[0]用于进程读取数据，fd[1]用于进程写入数据；

    3.匿名管道不具备存储数据的能力，数据一旦被读取，其它进程将不能从该管道中读取数据；

    4.匿名管道只能在有血缘关系的进程间通信；如父子进程和兄弟进程。

题目二

编写程序实现以下功能：

  1. 利用匿名管道实现兄弟进程间通信，要求

  2. 兄进程发送字符串“This is elder brother ，pid is (兄进程进程号)”给第进程；

  3. 第进程收到兄进程发送的数据后，给兄进程回复“This is younger brother ，pid is(第进程进程号)”；

    #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
int main() {
	int fd1[2],fd2[2];
	pipe(fd1);
	pipe(fd2);

	int pid;
	pid = fork();
	if(pid == 0) {
		printf("This is the elder brother!\n");
		printf("The elder's father's pid is: %d\n",getppid());

		close(fd1[1]);
		close(fd2[0]);
		char str1[64],str2[64];
		sprintf(str1,"This is the elder brother,pid is %d",getpid());

		if(write(fd2[1],str1,64) < 0)
			perror("write");

		if(read(fd1[0],str2,64) < 0)
			perror("read");
		else
			printf("The news from younger is: %s\n",str2);

	} else {
		if(fork() == 0) {
			printf("This is the younger brother!\n");
			printf("The younger's father's pid is: %d\n",getppid());

			close(fd1[0]);
			close(fd2[1]);
			char buf1[64],buf2[64];
			if(read(fd2[0],buf1,64) > 0) {
				printf("The news form elder is: %s\n",buf1);
				sprintf(buf2,"This is the younger brother,pid is %d",getpid());

				if(write(fd1[1],buf2,64) < 0)
					perror("write");
			} else
				perror("read");
		}
	}
}

    运行截图

    2

    结果分析

    ​ 我们都知道利用fork函数能创建一个子进程，但是如何利用fork函数创建兄弟进程呢？

    ​ 我们可以利用fork函数先建立一个子进程，在子进程中，将要发送的信息写入管道，然后再在父进程中再次调用fork函数，那么父进程里创建的子进程就是先前创建的进程的弟进程。我们可以让子进程将自己的父进程的pid打印，验证两进程是否是兄弟进程。

题目三

编写程序实现以下功能：

  1. 利用有名管道文件实现进程间通信，要求

  2. 写进程向有名管道文件写入10次“hello world”；

  3. 读进程读取有名管道文件中的内容，并依次打印。

    #include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
int main() {
	int pid,fd,i;
	if(mkfifo("fifotest",0666) < 0)
		perror("mkfifo");

	pid = fork();

	if(pid < 0)
		perror("fork");
	else if(pid == 0) {
		printf("This is the write process!\n");
		int fd = open("fifotest",0666);

		for(i = 0; i < 10; i++) {
			if(write(fd,"hello world",12) < 0)
				perror("write");
			sleep(1);
		}
		close(fd);
	} else {
		char str[128];
		printf("This is the read process!\n");
		int fd1 = open("fifotest",0666);

		for(i = 0; i < 10; i++) {
			if(read(fd1,str,128) < 0)
				perror("read");
			else
				printf("%s\n",str);
		}
		system("rm -f fifotest");
	}
}

    运行截图

    3

    结果分析

    有名管道的特点：

    1.有名管道支持读写操作，并且存在于文件系统中

    2.能够使用使用read和write直接对有名管道进行操作。

    3.有名管道是双向管道。

    4.可以用于任意进程间的通信，不像匿名管道具有局限性。

    我们能够像操作一个文件一样操作有名管道。

题目四

编写程序实现以下功能：

  1. 进程A向进程B发送SIGUSR1信号；

  2. 进程B收到信号后，打印字符串“receive SIGUSR1”；

  3. 要求用kill函数和signal函数实现以上功能；

    kill.c

    #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
void fun(int sig)
{
	if(sig == SIGUSR1)
	  printf("Reseived SIGUSR1!\n");
}
int main()
{
	int pid;
	
	if(signal(SIGUSR1,fun) < 0)
		perror("signal");
	
	pid = fork();
	
	if(pid < 0)
	  perror("fork");
	else if(pid == 0)
	{
		printf("This is B process!\n");
 
		sleep(2);
	}
	else
	{
		printf("This is A process!\n");
		if(kill(pid,SIGUSR1) < 0)
		  perror("kill");
		return 0;
	}
}

    signal.c

    #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
void fun(int sig) {
	if(sig = SIGUSR1)
		printf("Received SIGUSR1!\n");
}

int main() {
	printf("This is A process,mypid is: %d\n",getpid());
	signal(SIGUSR1,fun);
	pause();
	return 0;
}

    运行截图

    4

    结果分析

    ​ 信号是比较复杂的通信方式，用于通知进程中某种事件的发生。除了进程间的通信之外，进程还能发送信号给进程本身；每种信号类型都有对应信号处理程序。大多数的信号的系统默认操作是结束进程，当然，进程同样可以向系统请求采取某些代替的操作。

    例如：忽略信号、恢复信号的默认操作和执行一个预先设定的信号处理函数。

    ​ 信号的本质是在软件层次上对进程的中断机制的一种模拟。在原理上，一个进程收到某种信号和处理器收到中断请求是一样的。

    信号是所有的进程间的通信机制中唯一一个异步通信机制，可以看作是异步通知。

    信号的生命周期如下：

    我们通过signal和kill两种方式分别实现进程间的通信。

题目五

编写程序实现以下功能：

  1. 调用setitimer函数分别触发SIGALRM信号，SIGVTALRM信号，SIGPROF信号 ；（可以由多进程分别触发每个信号）

  2. 编写信号安装函数，在该函数内部能判断接受到的是什么信号，并把信号打印出来。

    #include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/time.h>
#include <unistd.h>
#include <sys/types.h>
void fun(int sig) {
	if(sig == SIGALRM)
		printf("Received the SIGALRM!\n");
	else if(sig == SIGVTALRM)
		printf("Receive the SIGVTALRM!\n");
	else if(sig == SIGPROF)
		printf("Receive the SIGPROf!\n");
}

int main() {
	if(signal(SIGALRM,fun) < 0)
		perror("signal");
	if(signal(SIGVTALRM,fun) < 0)
		perror("signal");
	if(signal(SIGPROF,fun) < 0)
		perror("signal");

	struct itimerval new_value1,new_value2,new_value3;

	new_value1.it_value.tv_sec = 1;
	new_value1.it_value.tv_usec = 0;
	new_value1.it_interval.tv_sec = 2;
	new_value1.it_interval.tv_usec = 0;

	setitimer(ITIMER_REAL,&new_value1,NULL);

	new_value2.it_value.tv_sec = 1;
	new_value2.it_value.tv_usec = 0;
	new_value2.it_interval.tv_sec = 2;
	new_value2.it_interval.tv_usec = 0;

	setitimer(ITIMER_VIRTUAL,&new_value2,NULL);

	new_value3.it_value.tv_sec = 1;
	new_value3.it_value.tv_usec = 0;
	new_value3.it_interval.tv_sec = 2;
	new_value3.it_interval.tv_usec = 0;

	setitimer(ITIMER_PROF,&new_value3,NULL);


	while(1);
	return 0;
}

    运行截图

    5

    结果分析

    setitimer函数的作用是提供精确的定时功能。通过改变settitime函数的第一个参数就能够改变函数触发的信号。

题目六

编写程序实现以下功能：

  1. 进程A向进程B发送SIGUSR1信号；

  2. 进程B收到信号后，打印字符串“receive SIGUSR1”；

  3. 要求用sigqueue函数和sigaction函数实现以上功能；

    sigaction.c

    #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
void fun(int sig) {
	if(sig == SIGUSR1)
		printf("Received SIGUSR1!\n");
}

int main() {
	printf("This is the receive process!\n");
	printf("The process pid is: %d\n",getpid());

	struct sigaction act,oldact;

	act.sa_handler = fun;
	act.sa_flags = 0;

	sigaction(SIGUSR1,&act,&oldact);

	pause();
	return 0;
}

    sigqueue.c

    #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
void handler(int sig,siginfo_t* p,void* q) {
	if(sig == SIGUSR1)
		printf("Received SIGUSR1!\n");
}

int main() {
	union sigval mysigval;
	struct sigaction act;

	int pid;
	pid = fork();

	if(pid < 0)
		perror("fork");
	else if(pid == 0) {
		printf("This is the received process!\n");
		act.sa_sigaction = handler;
		act.sa_flags = SA_SIGINFO;

		if(sigaction(SIGUSR1,&act,NULL) < 0)
			perror("sigaction");

		while(1);
	} else {
		printf("This is the send process!\n");
		sleep(1);
		if(sigqueue(pid,SIGUSR1,mysigval) < 0)
			perror("sigqueue");
	}
	return 0;
}

    运行截图

    6

题目七

编写程序实现以下功能：

  1. 进程A向进程B发送信号，该信号的附带信息为一个值为20的整数；

  2. 进程B完成接收信号的功能，并且打印出信号名称以及随着信号一起发送过来的整形变量值。

    #include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
void handler(int sig,siginfo_t* info,void *p) {
	printf("The num is: %d\n",info->si_value.sival_int);
}

int main() {
	int pid;
	struct sigaction act;
	act.sa_sigaction = handler;
	act.sa_flags = SA_SIGINFO;

	pid = fork();
	if(pid < 0)
		perror("fork");
	else if(pid == 0) {
		printf("This is the receive process!\n");
		if(sigaction(SIGUSR1,&act,NULL) < 0)
			perror("sigaction");

		while(1);
	} else {
		printf("This is the send process!\n");
		union sigval mysigval;
		mysigval.sival_int = 20;

		sleep(1);

		if(sigqueue(pid,SIGUSR1,mysigval) < 0)
			perror("sigqueue");
	}
	return 0;
}

    运行截图

    7

    结果分析

    信号发送进程通过sigqueue函数能够将更多的信息发送给信号接受进程。

题目八

编写代码完成以下功能：

  1. 创建共享内存，写进程通过键盘不断向内存写入“hello world”；

  2. 如果结束写操作，则通过键盘输入“end”；

  3. 读进程从共享内存读取数据，并打印。直到读到“end”为止。

    read.c

    #include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/shm.h>
#define MAXSIZE 1024

struct shm {
	int write;    //记录读进程是否已经将内容读取
	char buffer[MAXSIZE];
};

int main() {
	int shmid;
	struct shm *share;
	void *shmptr = NULL;

	if((shmid = shmget(0X44,MAXSIZE,0666|IPC_CREAT)) < 0)
		perror("shmget");
	if((shmptr = shmat(shmid,0,0)) == (void *)-1)
		perror("shmat");

	printf("This is the read process!!!\n");
	share = (struct shm *)shmptr;
	while(1) {
		if(share->write != 0) {
			if(!strncmp(share->buffer,"end",3) == 0) {
				printf("%s",share->buffer);
				share->write = 0;
			} else
				break;
		}
	}

	if(shmdt(shmptr) < 0)
		perror("shmdt");

	exit(0);
}

    write.c

    
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/shm.h>
#define MAXSIZE 1024
struct shm {
	int write;        //记录读进程是否已经将内容读取
	char buffer[MAXSIZE];
};

int main() {
	int shmid;
	void *shmptr = NULL;
	char str[MAXSIZE];    //存储输入的内容
	struct shm *share;

	if((shmid = shmget(0X44,MAXSIZE,0666|IPC_CREAT)) < 0)
		perror("shmget");
	if((shmptr = shmat(shmid,0,0)) == (void *)-1)
		perror("shmat");

	printf("This is the write process!!!\n");
	share = (struct shm *)shmptr;
	while(1) {
		if(share->write == 1) {
			sleep(1);
			printf("Waiting the read process!!!\n");
		}

		printf("please input hello world!!!\n");
		fgets(str,MAXSIZE,stdin);
		sprintf(share->buffer,"%s",str);
		share->write = 1;

		if(strncmp(str,"end",3) == 0)
			break;
		sleep(1);
	}
	if(shmdt(shmptr) < 0)
		perror("shmdt");
	exit(0);
}

    运行截图

    8

    结果分析

    ​ 共享内存就是多个进程同时访问一个逻辑内存区域，共享内存是两个不相关的进程传递数据的重要方式。进程将同一段物理内存连接到他们自己的地址空间之后，所有连接的进程都能访问这块内存。如果一个进程对这段内存进行更改，所做的更改将影响更改之后访问这段内存的进程。需要注意的是，共享内存并没有设置同步机制，也就是说，在上一个进程对内存进行更改操作完成之后 ，并没有机制阻止下一个进程对这段内存的更改。因此，我们需要利用其它的机制对共享内存来同步进程对共享内存的访问。例如：信号量。

    因为是直接对内存进行操作，省去了数据传输这一步骤，因此共享内存的速度最快。

题目九

编写代码完成以下功能：

  1. 进程A向消息队列发送消息“hello，world”

  2. 进程B从消息队列读取消息，并打印。

  3. 进程C向消息队列发送“自己的姓名”

  4. 进程D从消息队列中取出姓名字符串，并打印

    
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <unistd.h>
#include <sys/msg.h>
#include <sys/types.h>
struct msg {
	char msg_str[128];
};

int main() {
	int qid;
	struct msg mymsg;
	if(qid = msgget(0x66,0666|IPC_CREAT) < 0)
		perror("msgget");

	int pid;
	pid = fork();
	if(pid < 0)
		perror("fork");
	else if(pid == 0) {
		printf("This is A process!\n");
		sprintf(mymsg.msg_str,"hello world");

		if(msgsnd(qid,&mymsg,128,0) < 0)
			perror("msgsnd");
	} else {
		if(fork() == 0) {
			printf("This is B process!\n");
			if(msgrcv(qid,&mymsg,128,0,0) < 0)
				perror("msgrcv");

			printf("The msg is: %s\n",mymsg.msg_str);
		} else if(fork() == 0) {
			printf("This is the C process!\n");
			sprintf(mymsg.msg_str,"Mamingyuan");

			if(msgsnd(qid,&mymsg,128,0) < 0)
				perror("msgsnd");
		} else {
			printf("This is D process!\n");
			if(msgrcv(qid,&mymsg,128,0,0) < 0)
				perror("msgrcv");

			printf("The msg is: %s\n",mymsg.msg_str);
		}
	}
	return 0;
}

    运行截图

    9

    结果分析

    ​ 消息队列也叫报文队列，是一个消息的链表。可以把消息看作是一个记录，具有特定的格式以及优先级。对消息队列具有写权限的进程可以按照一定的规则向消息队列中添加消息，而对消息队列具有写权限的进程可以从消息队列中读走消息。和管道相似的是，消息一旦从消息队列中被读走，则消息队列中便不在存在此条消息。

    IPC消息队列的缺省最大数为16；

    每个消息缺省最大值为8192字节；

    队列中的最大值缺省为16384字节；

    每个消息队列都有其对应的属性信息，存储在struct_msqid_ds结构体中。

    每个消息队列都有一个对应的id，标识消息队列的唯一性。

jiuqi_玖柒
关注
  • 10
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统进程间通信实验
11-22
通过对进程间通信同步/互斥问题的编程实现，加深理解信号量和 P、V 操作的原理； 对 Windows 或 Linux 涉及的几种互斥、同步机制有更进一步的了解；熟悉 Windows 或 Linux 中定义的与互斥、同步有关的函数。
实验 Linux进程通信的参考答案
07-05
在实验中，我们使用 fork 函数创建了多个进程，并使用信号机制和管道通信机制实现了进程之间的通信。 四、实验结果 通过实验，我们可以看到，使用信号机制和管道通信机制可以实现进程之间的通信和数据交换。这对于...
Linux操作系统实验 —— 进程间通信
m0_74738450的博客
01-24 1593
本次实验主要围绕Linux环境下的进程间通信（IPC）展开，涉及了不同的通信方法和进程同步的概念。总体而言，进程之间的通信主要有两种方式，分别是消息队列和共享内存，除此之外，我们还学习了如何使用多线程和信号量的方法解决生产者-消费者的问题，增强了对于进程通信和进程同步的理解和掌握。1.消息队列：- 消息队列是一种进程间通信的方式，通过在进程间传递消息实现数据交换。- 在实验中，我们通过使用msgget、msgsnd和msgrcv等系统调用来创建消息队列、向队列发送消息和从队列接收消息。
实验三linux进程间通信,实验五：进程间通信
weixin_42149153的博客
05-05 648
《实验五：进程间通信》由会员分享，可在线阅读，更多相关《实验五：进程间通信(8页珍藏版)》请在人人文库网上搜索。1、精选文库 实验五：进程间通信 实验目的： 学会进程间通信方式：无名管道，有名管道，信号，共享内存 实验要求： (一)在父进程中创建一无名管道，并创建子进程来读该管道，父进程来写该管道 (二)在进程中为 SIGBUS注册处理函数，并向该进程发送SIGBUS信号 (三)创建一共享内存，实...
操作系统实验--进程间通信
海到无边天作岸 山登绝顶我为峰
09-27 7984
进程间通信 一、实验名称 进程间通信 二、实验内容 学生独立设计并实现消息传递系统进程间交换数据的任务。 三、实验原理和设计思路 在Linux系统下用signal()函数进行进程间通信，pipe()函数创建管道进行数据传送。 四、源代码 1.软中断通信 #include<unistd.h> #include<stdio.h> #include<signal.h> void waiting(),stop(); int wait_mark; main() { int p1,p
Linux实验五：进程间通信（一）
Morse_Chen的博客
05-24 1240
Linux程序设计实验五：进程间通信（一）。
实验六 进程间通信——共享内存
diOSyu的博客
09-24 4389
一、实验目的 1、了解采用共享内存通信的原理； 2、掌握共享内存的创建及使用方法。 二、实验内容 1、创建写进程，其功能为创建共享内存并映射到当前进程地址空间，然后向内存写入数据，直至遇到’#’为止； 2、读进程使用和写进程相同的KEY创建共享内存并映射到进程地址空间，然后从内存读数据并打印在终端上； 3、注意通过一定的方式来实现读写进程之间的同步。 三、源程序 sh...
实验四 进程间通信——有名管道
diOSyu的博客
09-24 3607
一、实验目的 1、了解有名管道通信的原理； 2、掌握有名管道的创建及使用方法。 二、实验内容 1、编写以非阻塞方式打开的写进程，其功能为接收用户从键盘输入的字符串，写入FIFO； 2、编写以非阻塞方式打开的读进程，功能为从FIFO中读取数据并打印到终端，遇到字符’p’时暂停读取数据； 3、编译并执行读进程、写进程。 三、源程序 fiforead.c： ...
操作系统实验三进程间通信
Time木的博客
06-11 8925
操作系统实验三进程间通信
实验五 进程间通信——信号机制
diOSyu的博客
09-24 3173
一、实验目的 1、了解采用信号机制通信的原理； 2、掌握信号的使用方法。 二、实验内容 编写sigaction.c源程序，实现如下功能： 1、 a.捕获“Ctrl-C”信号时，打印”I have get SIGINT.”； b.捕获“Ctrl-\”信号时，打印”I have get SIGQUIT.”。 2、 a.设置进程屏蔽字，本例中屏蔽信号SIGINT，并测试SIGINT是否被屏...
linux进程间的通信实验,linux实验进程之间的通信.doc
weixin_39783156的博客
05-14 79
院 系： 计算机学院实验课程：linux内核设计与实现实验项目：进程之间的通信指导老师：冯刚开课时间： 2010 ～ 2011 年度第 2 学期专 业：计算机科学与技术(师范)班 级：2班华南师范大学教务处一、实验名称进程之间的通信二、实验目的为了理解和掌握UNIX和Linux进程通信系统调用的功能，这里给出了进程通信实现机制中使用的系统调用命令的格式和如何利用系统调用命令进行进...
操作系统实验三 进程间通信
流苏的博客
09-21 2891
操作系统实验三 进程间通信
操作系统实验四 进程的管道通信 实验报告
10-23
在操作系统中，进程之间的通信是实现多任务协作和数据共享的关键技术。本实验重点探讨了在Linux环境下，如何使用管道（pipe）这种通信机制来实现父子进程间的通信。实验目标在于理解和掌握管道通信的基本原理以及...
实验四：Linux下进程管道通信.docx
04-13
总结起来，管道通信是操作系统中进程间通信的一个重要方法，它不仅限于父子进程，也可以在有共同祖先的进程之间共享。通过这个实验，我们加深了对管道机制的理解，并学会了如何在实际编程中应用它。
实验五 进程间通信.docx
最新发布
05-24
### 实验五 进程间通信 #### 实验目的 本次实验旨在加深学生对进程间通信（IPC）机制的理解，并通过实践操作掌握进程通信的基本原理和技术应用。具体目标包括： 1. **理解进程通信机制**：熟悉信号、管道、消息...
实验5 linux网络编程
热门推荐
玖柒IT
12-02 1万+
实验5 linux网络编程 题目一 完成基于TCP的客户端和服务器程序编写，要求服务器采用循环方式处理客户端的数据。 server.c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #include <sys/socket.h> #include <unistd.h> #include <errno.h> #incl
实验1 linux文件系统
玖柒IT
12-02 1万+
实验1 linux文件系统 题目一 编写代码，完成以下功能： 创建文件file1，写入字符串“abcdefghijklmn”； 创建文件file2，写入字符串“ABCDEFGHIJKLMN”; 读取file1中的内容，写入file2，使file2中的字符串内容为“ ABCDEFGHIJKLMNabcdefghijklmn” #include<stdio.h> #include<dirent.h> #include<stdlib.h> #include<s
实验2 Linux进程管理
玖柒IT
12-03 9423
实验2 进程的管理 题目一 编写代码，实现以下功能： 打印当前所有环境变量的值； 添加新的环境变量NEWENV=first； 修改环境变量NEWENV的值为second； 打印环境变量NEWENV的值。 #include <stdio.h> #include <stdlib.h> #include <sys/stat.h> #include <unistd.h> extern char **environ; int main() { cha
Linux编程实战：进程间通信探索
在这个Linux实验中，主要目标是让学生深入理解并实践四种关键的进程间通信机制：管道、信号、共享内存和消息队列。实验性质为验证性，共需4个学时完成。以下是详细的内容概述： 1. 管道（Pipe）： - 匿名管道：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值