Linux进程以及进程间管道通信

最新推荐文章于 2024-07-08 22:09:55 发布
最新推荐文章于 2024-07-08 22:09:55 发布
阅读量234 收藏
点赞数
分类专栏： linux 文章标签： linux c语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45205160/article/details/128382749
版权

文章目录

进程相关概念

程序和进程

程序：死的。只占用磁盘空间。
进程；活的。运行起来的程序。占用内存、cpu 等系统资源。

并发和并行

并发和并行：并行是宏观上并发，微观上串行
并发：是同一个cpu，执行不同的进程，使用不同的 时间片，只是有一个进程在执行
并行：是不同的cpu,使得多个进程同时的执行

进程控制块

struct task_struct {
	volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
	void *stack;
	atomic_t usage;
	unsigned int flags;	/* per process flags, defined below */
	unsigned int ptrace;

	//........

	struct pipe_inode_info *splice_pipe;
#ifdef	CONFIG_TASK_DELAY_ACCT
	struct task_delay_info *delays;
#endif
#ifdef CONFIG_FAULT_INJECTION
	int make_it_fail;
#endif
};

// /usr/src/linux-headers-3.16.0-30/include/linux/sched.h文件中可以查看struct task_struct 结构体定义。其内部成员有很多
/* 
    * 进程id。系统中每个进程有唯一的id，在C语言中用pid_t类型表示，其实就是一个非负整数。
    * 进程的状态，有就绪、运行、挂起、停止等状态。
    * 进程切换时需要保存和恢复的一些CPU寄存器。
    * 描述虚拟地址空间的信息。
    * 描述控制终端的信息。
    * 当前工作目录（Current Working Directory）。
    * umask掩码。
    * 文件描述符表，包含很多指向file结构体的指针。
    * 和信号相关的信息。
    * 用户id和组id。
    * 会话（Session）和进程组。
    * 进程可以使用的资源上限（Resource Limit）。
*/
  • 进程状态

进程基本的状态有5种。分别为初始态，就绪态，运行态 , 挂起态与终止态。
其中初始态为进程准备阶段，常与就绪态结合来看。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iRlWn3RV-1671507698300)(file:///C:\Users\dongfang\AppData\Local\Temp\ksohtml9364\wps2.jpg)]

环境变量

常见的环境变量

1、PATH：用来记录文件的可执行路径，echo $PATH
2、SHELL：用来记录当前Shell，它的值通常是/bin/bash。echo $SHELL
3、TERM：当前终端类型，在图形界面终端下它的值通常是xterm，echo $TERM
4、LANG：语言和locale，决定了字符编码以及时间、货币等信息的显示格式。
5、HOME：当前用户主目录的路径，很多程序需要在主目录下保存配置文件，使得每个用户在运行该程序时都有自己的一套配置。

常用函数

1、getenv函数：获取环境变量值
    char *getenv(const char *name); 	
	成功：返回环境变量的值；失败：NULL (name不存在)
2、setenv函数：设置环境变量的值	
    int setenv(const char *name, const char *value, int overwrite);  	
	成功：0；失败：-1
	参数overwrite：若存在是否覆盖	
        1：覆盖原环境变量 
        若存在且overwrite == 0 则忽略value
		0：不覆盖。(该参数常用于设置新环境变量，如：ABC = haha-day-night)
3、unsetenv函数：删除环境变量name的定义
    int unsetenv(const char *name); 	
	成功：0；失败：-1 
	注意事项：name不存在仍返回0(成功)，当name命名为"ABC="时则会出错。

查看当前进程所有环境变量

#include <stdio.h>

extern char **environ;//eg : environ[1] = "SHLVL=1"

int main(void){
	int i;
	for(i = 0; environ[i] != NULL; i++){
		printf("%s\n", environ[i]);
	}
	return 0;
}

获取name对应环境变量

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

extern char **environ;

char *my_getenv(const char *name){
	char *p = NULL;
	int i, len;

	for(i = 0; environ[i] != NULL; i++){
		p = strstr(environ[i], "=");//获取“=”所在位置
		len = p - environ[i];//获取环境变量name的长度
		if(strncmp(name, environ[i], len) == 0){//对比是否相等
			return p+1;//返回对应的环境变量
		}
	}
	return NULL;
}

int main(int argc, char *argv[]){
	char *p = NULL;

	p = getenv(argv[1]);
	//p = my_getenv(argv[1]);
    
	if (p == NULL)
		printf("there is no match\n");
	else
		printf("%s\n", p);
	return 0;
}
/*执行结果
ubuntu@ubuntu:~/LearnCPP/linux_test/path_test$ ./getenv PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
*/

setenv和unsetenv例子

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

int main(void)
{
	char *val;
	const char *name = "ABD";

	val = getenv(name);
	printf("1, %s = %s\n", name, val);

	setenv(name, "haha-day-and-night", 1);//设置覆盖环境变量值为haha-day-and-night

	val = getenv(name);
	printf("2, %s = %s\n", name, val);

#if 0
	unsetenv("ABD");//删除环境变量ABD
	val = getenv(name);
	printf("3, %s = %s\n", name, val);
#else
	int ret = unsetenv("ABD=");  //name=value:value
	printf("ret = %d\n", ret);

	val = getenv(name);
	printf("3, %s = %s\n", name, val);
#endif

	return 0;
}
/*执行结果
ubuntu@ubuntu:~/LearnCPP/linux_test/path_test$ ./setenv 
1, ABD = 123
2, ABD = haha-day-and-night
ret = -1
3, ABD = haha-day-and-night
正确删除环境变量
ubuntu@ubuntu:~/LearnCPP/linux_test/path_test$ ./setenv 
1, ABD = 123
2, ABD = haha-day-and-night
3, ABD = (null)
*/

进程控制

fork()、getpid()、getppid()

pid_t fork(void);
失败返回-1；成功返回① 父进程返回子进程的ID(非负) ②子进程返回 0 。
创建一个子线程。pid_t类型表示进程ID，但为了表示-1，它是有符号整型。
(0不是有效进程ID，init最小，为1)。不是fork函数能返回两个值，而是fork后，fork函数变为两
个进程，每个进程各自返回一个。

pid_t getpid(void);
获取当前进程id

pid_t getppid(void);
获取当前进程的父进程id

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <pthread.h>

int main(int argc,char* argv[]){

	printf("before fork1\n");
	printf("before fork2\n");
	printf("before fork3\n");
	printf("before fork4\n");

	pid_t pid = fork();

	if(pid == -1){
		perror("fork err");
		exit(1);
	}else if(pid == 0){
		printf("children pid is create  -- pid = %d \n,parent pid = %d",getpid(),getppid());
	}else if(pid >0){
		printf("parent pid = %d create children pid is %d\n,parent parent pid = %d \n",getpid(),pid,getppid());
	}
	
	printf("-----------end of file\n");
	return 0;
}
/*
ubuntu@ubuntu:~/LearnCPP/linux_test/pcb_test$ ./pcb_test 
before fork1
before fork2
before fork3
before fork4
parent pid = 7083 create children pid is 7084
,parent parent pid = 7077 
-----------end of file
children pid is create  -- pid = 7084 
,parent pid = 7083-----------end of file
*/

循环创建多个子进程

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <pthread.h>

int main(int argc,char* argv[]){
	
	int i =0;
	pid_t pid;
	for(i =0;i<5;i++){
		pid = fork();
		if(pid == 0){
			break;
		}
	}
	if(i == 5){
		sleep(5);
		printf("parent process\n");
	}else{
		sleep(i);//让进程按照顺序打印
	    printf("I am %dth chilren\n",i+1);
	}
	printf("-----------end of file\n");
	return 0;
}
/*
ubuntu@ubuntu:~/LearnCPP/linux_test/pcb_test$ ./fork_loop 
I am 1th chilren
-----------end of file
I am 2th chilren
-----------end of file
I am 3th chilren
-----------end of file
I am 4th chilren
-----------end of file
I am 5th chilren
-----------end of file
parent process
-----------end of file
*/

getuid()、getgid()、geteuid()、getegid()

获取当前进程实际用户ID
uid_t getuid(void);
获取当前进程有效用户ID
uid_t geteuid(void);

获取当前进程使用用户组ID
gid_t getgid(void);
获取当前进程有效用户组ID
gid_t getegid(void);

进程共享

  • 父子进程相同：

    刚 fork 后。 data 段、text 段、堆、栈、环境变量、全局变量、宿主目录位置、进程工作目录位

置、信号处理方式

  • 父子进程不同：

    进程 id、返回值、各自的父进程、进程创建时间、闹钟、未决信号集

  • 父子进程共享：

    读时共享、写时复制。———————— 全局变量。

共享内容：1、文件描述符 2. mmap 映射区。

父子进程GDB调试

gdb 调试：

  • 设置父进程调试路径：set follow-fork-mode parent (默认)

  • 设置子进程调试路径：set follow-fork-mode child

注意，一定要在fork函数调用之前设置才有效。

exec函数族

当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。将当前进程的.text、.data替换为所要加载的程序的.text、.data，然后让进程从新的.text第一条指令开始执行，但进程ID不变。

exec函数族函数

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);

exec函数一般规律

exec 函数族一般规律：
exec 函数一旦调用成功，即执行新的程序，不返回。只有失败才返回，错误值-1，所以通常我们
直接在 exec 函数调用后直接调用 perror()，和 exit()，无需 if 判断。

  • l(list) :命令行参数列表
  • p(path) :搜索 file 时使用 path 变量
  • v(vector) :使用命令行参数数组
  • e(environment) :使用环境变量数组，不适用进程原有的环境变量，设置新加载程序运行的

环境变量事实上，只有 execve 是真正的系统调用，其他 5 个函数最终都调用 execve，是库函数，所以 execve 在 man 手册第二节，其它函数在 man 手册第 3 节。

execl执行test程序

  • test程序
#include <stdio.h>

int main(){
	printf("hello my name is child process\n");

	return 0;
}
  • execl程序
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>

int main(int argc,char* argv[]){

	pid_t pid = fork();

	if(pid == -1){
		perror("fork error");
		exit(1);
	}else if(pid == 0){
		execl("./test","./test",NULL);//NULL哨兵	
		perror("exec error");
		exit(1);
	}else if(pid >0){
		sleep(1);
		printf("i am parent : %d \n",getpid());		
	}

	return 0;
}

/*
ubuntu@ubuntu:~/LearnCPP/linux_test/exec_test$ ./exec_test2 
hello my name is child process
i am parent : 9095 
*/

execl执行ls

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

int main(int argc,char* argv[]){

	pid_t pid = fork();

	if(pid == -1){
		perror("fork error");
		exit(1);
	}else if(pid == 0){
		execl("/bin/ls","ls","-l",NULL);//NULL哨兵	
		perror("exec error");
		exit(1);
	}else if(pid >0){
		sleep(1);
		printf("i am parent : %d \n",getpid());		
	}

	return 0;
}
/*
ubuntu@ubuntu:~/LearnCPP/linux_test/exec_test$ ./exec_test4 
总用量 132
-rwxrwxr-x 1 ubuntu ubuntu  8912 9月   7 16:25 exec_ps
-rw-rw-r-- 1 ubuntu ubuntu   403 9月   7 16:25 exec_ps.c
-rwxrwxr-x 1 ubuntu ubuntu  8920 9月   7 15:18 exec_test
-rwxrwxr-x 1 ubuntu ubuntu  8920 9月   7 15:24 exec_test2
-rw-rw-r-- 1 ubuntu ubuntu   402 9月   7 15:54 exec_test2.c
-rwxrwxr-x 1 ubuntu ubuntu  8920 9月   7 15:28 exec_test3
-rw-rw-r-- 1 ubuntu ubuntu   399 9月   7 15:28 exec_test3.c
-rwxrwxr-x 1 ubuntu ubuntu  8920 9月   7 15:56 exec_test4
-rw-rw-r-- 1 ubuntu ubuntu   404 9月   7 15:56 exec_test4.c
-rw-rw-r-- 1 ubuntu ubuntu   400 9月   7 15:18 exec_test.c
-rw-rw-r-- 1 ubuntu ubuntu 34074 9月   7 16:25 ps.out
-rwxrwxr-x 1 ubuntu ubuntu  8600 9月   7 15:24 test
-rw-rw-r-- 1 ubuntu ubuntu    91 9月   7 15:22 test.c
i am parent : 9208 
*/

execlp函数执行ls

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

int main(int argc,char* argv[]){

	pid_t pid = fork();

	if(pid == -1){
		perror("fork error");
		exit(1);
	}else if(pid == 0){
		execlp("ls","ls","-l",NULL);//NULL哨兵	
		perror("exec error");
		exit(1);
	}else if(pid >0){
		sleep(1);
		printf("i am parent : %d \n",getpid());		
	}

	return 0;
}
/*
ubuntu@ubuntu:~/LearnCPP/linux_test/exec_test$ ./exec_test
总用量 132
-rwxrwxr-x 1 ubuntu ubuntu  8912 9月   7 16:25 exec_ps
-rw-rw-r-- 1 ubuntu ubuntu   403 9月   7 16:25 exec_ps.c
-rwxrwxr-x 1 ubuntu ubuntu  8920 9月   7 15:18 exec_test
-rwxrwxr-x 1 ubuntu ubuntu  8920 9月   7 15:24 exec_test2
-rw-rw-r-- 1 ubuntu ubuntu   402 9月   7 15:54 exec_test2.c
-rwxrwxr-x 1 ubuntu ubuntu  8920 9月   7 15:28 exec_test3
-rw-rw-r-- 1 ubuntu ubuntu   399 9月   7 15:28 exec_test3.c
-rwxrwxr-x 1 ubuntu ubuntu  8920 9月   7 15:56 exec_test4
-rw-rw-r-- 1 ubuntu ubuntu   404 9月   7 15:56 exec_test4.c
-rw-rw-r-- 1 ubuntu ubuntu   400 9月   7 15:18 exec_test.c
-rw-rw-r-- 1 ubuntu ubuntu 34074 9月   7 16:25 ps.out
-rwxrwxr-x 1 ubuntu ubuntu  8600 9月   7 15:24 test
-rw-rw-r-- 1 ubuntu ubuntu    91 9月   7 15:22 test.c
i am parent : 9235 
*/

execlp执行ps aux命令,并存入文件

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>

int main(int argc,char* argv[]){

	int fd = open("ps.out",O_RDWR|O_CREAT|O_TRUNC,0664);
	if(fd == -1){
		perror("open error");
		exit(1);
	}

	dup2(fd,STDOUT_FILENO);

	pid_t pid = fork();

	if(pid == 0){
		execlp("ps","ps","-aux",NULL);
		close(fd);
		perror("exec error");
		exit(1);
	}

	return 0;
}

执行后的结果

在这里插入图片描述

孤儿进程和僵尸进程

孤儿进程：

​ 父进程先于子进终止，子进程沦为“孤儿进程”，会被 init 进程领养。

僵尸进程：

​ 子进程终止，父进程尚未对子进程进行回收，在此期间，子进程为“僵尸进程”。 kill 对其

无效。这里要注意，每个进程结束后都必然会经历僵尸态，时间长短的差别而已。

​ 子进程终止时，子进程残留资源 PCB 存放于内核中，PCB 记录了进程结束原因，进程回收就是回

收 PCB。回收僵尸进程，得 kill 它的父进程，让孤儿院去回收它。

回收子进程

wait()函数

回收子进程退出资源， 阻塞回收任意一个。
pid_t wait(int *status)

参数：（传出） 回收进程的状态。
返回值：成功： 回收进程的 pid
失败： -1， errno

wait阻塞回收单个子进程

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

int main(int argc,char* argv[]){

	pid_t pid , wpid;
	int status;

	pid = fork();
	if(pid == 0){
		printf("child my parent pid = %d,going to sleep 5s\n",getppid());
		sleep(5);
		printf("------child die------\n");
	}else if(pid >0){
			wpid = wait(&status);
			if(wpid == -1){
				perror("wait error");
				exit(1);
			}
			printf("I am parent ,pid = %d,myson = %d\n",getpid(),pid);
			printf("parent finish\n");
	}else{
		perror("fork");
		return 1;
	}
	
	return 0;
}
/*
ubuntu@ubuntu:~/LearnCPP/linux_test/wait_test$ ./wait_test
child my parent pid = 9511,going to sleep 5s
------child die------
I am parent ,pid = 9511,myson = 9512
parent finish
*/

wait获取子进程退出值和异常终止信号

  • 获取子进程正常终止值：

    WIFEXITED(status) --》 为真 --》调用WEXITSTATUS(status)–》 得到 子进程 退出值。

  • 获取导致子进程异常终止信号：

    WIFSIGNALED(status) --》 为真 --》调用 WTERMSIG(status) --》 得到 导致子进程异常

终止的信号编号。

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

int main(int argc,char* argv[]){

    pid_t pid, wpid;
    int status;

    pid = fork();

    //一次wait和waitpid一次只能回收一个子进程
    //wait来说是随机的，那个先，就先回收那个子进程

    if(pid == 0 ){//子进程
        printf("this is child process: child id = %d,sleep 10s\n",getpid());
        sleep(10);
        printf("-------child die--------\n");
        return 87;
    }else if(pid > 0){//父进程
        wpid = wait(&status);

        if(wpid == -1){
            perror("wait error");
            exit(1);
        }else{
            if(WIFEXITED(status)){//正常结束
                printf("child process exit : %d\n",WEXITSTATUS(status));
            }else if(WIFSIGNALED(status)){//被信号kill
                printf("child process kill by singal:%d",WTERMSIG(status));
            }else if(WIFSTOPPED(status)){//被信号stop
                printf("child process stop by singal:%d",WSTOPSIG(status));
            }
        }
    }else{
        perror("fork error");
        return -1;
    }

    return 0;
}
/*
//正常终止
ubuntu@ubuntu:~/LearnCPP/linux_test/wait_test$ ./wait_test3
this is child process: child id = 9589,sleep 10s
-------child die--------
child process exit : 87
*/

waitpid()函数

pid_t waitpid(pid_t pid, int *status, int options)
waitpid(-1, &status, 0)相当于wait(&status);
参数：

  • pid：指定回收某一个子进程 pid

    ​ > 0: 待回收的子进程 pid
    ​ -1：任意子进程
    ​ 0：同组的子进程。

  • status：（传出） 回收进程的状态。

  • options：WNOHANG 指定回收方式为，非阻塞。如果是0表示阻塞

返回值：

​ > 0 : 表成功回收的子进程 pid
​ 0 : 函数调用时， 参 3 指定了 WNOHANG， 并且，没有子进程结束。
​ -1: 失败。errno

回收多个子进程

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

int main(int argc, char *argv[]){

    int n = 5, i;
    pid_t pid, wpid;

    for (i = 0; i < 5; i++){
        pid = fork();
        if (pid == 0)
        {
            break;
        }
    }
    if (n == i){ //父进程
        // sleep(n);
        // printf("I am parent , pid = %d",getpid());
        // while ((wpid = waitpid(-1, NULL, 0))) { //阻塞的回收
        //     printf("wait child %d\n", wpid);
        //     if (wpid == -1){
        //         break;
        //     }
        // }
        while((wpid = waitpid(-1,NULL,WNOHANG) != -1)){//非阻塞的回收
            sleep(1);
            if(wpid > 0){
                printf("wait child %d\n",wpid);
            }else if (wpid == 0){
                sleep(1);
                printf("wait child finish");
                continue;
            }
        }
    }
    else{
        sleep(i);
        printf("I am %dth child ,pid = %d\n", i + 1, getpid());
    }

    return 0;
}
/*
ubuntu@ubuntu:~/LearnCPP/linux_test/waitpid_test$ ./waitpid_test
I am 1th child ,pid = 9749
wait child 1
I am 2th child ,pid = 9750
I am 3th child ,pid = 9751
wait child 1
I am 4th child ,pid = 9752
wait child 1
I am 5th child ,pid = 9753
wait child 1
wait child 1
wait child 1
*/

回收单个进程

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

int main(int argc,char* argv[]){

    pid_t pid, wpid;
    int i = 0;

    for (i = 0; i < 5;i++){//循环产生5个子进程
        pid = fork();//父进程执行
        if(pid == 0){//子进程不在衍生，子进程执行
            break;
        }
        if(i == 2){//第三个子进程
            wpid = pid;//父进程执行
        }
    }

    if( 5 == i){//父进程
        sleep(1);
        pid_t p = waitpid(wpid, NULL, 0);//阻塞回收wpid进程
        if(p > 0){
            printf("wait pid = %d finish\n",wpid);
        }
    }
    else { //子进程
        //
        sleep(i);
        printf("I am %dth child , my pid = %d\n",i+1,getpid());
    }

    return 0;
}

进程间通信

常见的进程间通信

进程间通信的常用方式：

  • 管道：简单

  • 信号：开销小

  • mmap 映射：非血缘关系进程间

  • socket（本地套接字）：稳定

管道pipe

调用pipe系统函数即可创建一个管道。有如下特质：

  • 其本质是一个伪文件(实为内核缓冲区)
  • 由两个文件描述符引用，一个表示读端，一个表示写端。
  • 规定数据从管道的写端流入管道，从读端流出。

管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。
管道的局限性：

​ ① 数据不能进程自己写，自己读。
​ ② 管道中数据不可反复读取。一旦读走，管道中不再存在。
​ ③ 采用半双工通信方式，数据只能在单方向上流动。
​ ④ 只能在有公共祖先的进程间使用管道。

int pipe(int pipefd[2]); 成功：0；失败：-1，设置errno
函数调用成功返回r/w两个文件描述符。无需open，但需手动close。规定：fd[0] → r； fd[1] → w。

用于有血缘关系进程之间的通信

pipe通信demo

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

//管道命令pipe test
int main(int argc,char* argv[]){

    int fd[2];//管道
    int ret;
    pid_t pid;
    char *buf = "hello world\n";
    char readBuf[1024];//接收管道数据buf

    ret = pipe(fd);//创建管道并打开

    if(ret == -1){
        perror("pipe error");
        exit(1);
    }

    pid = fork();
    if (pid > 0){//父进程
        close(fd[0]);//关闭读段
        write(fd[1],buf,strlen(buf));//向写管道中写入
        sleep(1);//保证子进程先于父进程结束
        close(fd[1]);  //关闭写管道
    }else if(pid == 0){//子进程
        close(fd[1]);//关闭写管道
        ret = read(fd[0],readBuf,sizeof(readBuf));
        printf("child read %d char\n",ret);
        write(STDOUT_FILENO, readBuf, ret);
        close(fd[0]);
    }

    return 0;
}
/*
ubuntu@ubuntu:~/LearnCPP/linux_test/pipe_test$ ./pipe_test 
child read 12 char
hello world
*/

pipe实现ls | wc -l

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

//利用pipe管道通信实现ls | wc -l
//使用dup2 fork pipe等函数

int main(int argc,char* argv[]){

    int fd[2];
    int ret;
    pid_t pid;

    ret = pipe(fd);
    if(ret == -1){
        perror("pipe error");
        exit(1);
    }

    pid = fork();
    if(pid == -1){
        perror("fork error");
        exit(1);
    }else if(pid == 0){//子程序进行写端，将STDOUT重定向到fd[1]中
        close(fd[0]);//关闭读端
        dup2(fd[1],STDOUT_FILENO);//重定向
        execlp("ls","ls",NULL);//执行ls命令
        close(fd[1]);
        perror("execlp error");
        exit(1);
    }
    else if (pid > 0)
    { //父程序进行读端，将STDIN重定向到fd[1]中
        close(fd[1]);
        dup2(fd[0],STDIN_FILENO);//重定向
        execlp("wc","wc","-l",NULL);
        close(fd[0]);
        perror("execlp error");
        exit(1);
    }

    return 0;
}
/*
ubuntu@ubuntu:~/LearnCPP/linux_test/pipe_test$ ./pipe1 
10
*/

fifo命名管道

int mkfifo(const char *pathname, mode_t mode); 成功：0； 失败：-1

** 可以应用于无血缘关系进程之间的通信

创建fifo命名管道

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <string.h>
#include <errno.h>

void sys_errno(char* str){	
	perror("str");
	exit(1);
}

int main(int argc,char** argv){
	
	int ret = mkfifo("myfifo",0664);
	if(ret == -1){	
		sys_errno("fifo err");	
	}
	return 0;
}

程序1写fifo

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

int main(int argc,char* argv[]){	
	int fd,i;
	char buf[4096];

	fd = open(argv[1],O_WRONLY);
	if(fd<0){
		perror("open err");
		exit(1);
	}
	i = 0;

	while(1){	
		sprintf(buf, "hello itcast %d\n",i++);
		write(fd,buf,strlen(buf));
		sleep(1);	
	}	
	close(fd);
	return 0;
}

程序2读取fifo

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

void sys_errno(char* str){
	
	perror("str");
	exit(1);
}

int main(int argc,char* argv[]){
	
	int fd,i,len;
	char buf[4096];

	fd = open(argv[1],O_RDONLY);
	if(fd<0){
		perror("open err");
		exit(1);
	}
	i = 0;
	
//	write(fd,"nihao\n",strlen("nihao\n"));
	while(1){
		len = read(fd,buf,strlen(buf));		
		write(STDOUT_FILENO,buf,len);
		sleep(1);	
	}	
	close(fd);
	return 0;
}

fifo执行结果

在这里插入图片描述

s

东方欲晓w
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux中进程间通信之管道
MOON5555的博客
11-20 279
进程间通信：管道 管道：1、有名管道            2、无名管道 为什么要引入管道呢？ 答：因为普通文件存储在磁盘中，读写效率低                管道文件存储在内存中，读写效率高 1、有名管道 （1）创建：mkfifo fifo （2）open时需要两个进程（r读、w写）一起操作 （3）有名管道可以在任意两个进程间使用 （4）管道有读端和写
Linux讲解 进程间通信 管道
Hanani_Jia的博客
09-21 692
  今天我们讲解进程间的通信，首先回顾一下进程的概念：进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。   进程的用户空间是相互独立的，一般来说是不能相互访问的，但是很多情况需要我们不同的进程共同完成一个任务，或者进程之间需要沟通交流的时候，就必须要用到我们的进程间通信。   经...
【Shell 命令集合 系统设置 】⭐⭐⭐Linux 设置环境变量setenv命令 使用指南
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-28 6229
setenv命令是用于在Linux系统中设置环境变量的命令。环境变量是一种在操作系统中存储的键值对，用于存储系统配置信息、用户偏好设置以及程序运行所需的路径等信息。通过设置环境变量，可以方便地在不同的程序之间共享数据。
python os.environ_Python os.environ能获取到的环境变量，在os.environ.getenv得不到为什么？...
weixin_42344284的博客
02-19 1140
>>> import os>>> os.path.exists('.env')True>>> for line in open('.env'):... var = line.strip().split('=')... print var...['FLASK_CONFIG ', ' production']>>>...
razor 怎样使用session变量_Linux 环境变量(Environment Variable)
weixin_39581845的博客
11-10 256
Linux 环境在 Linux Shell 登录成功以后，Linux 会从文件中获取一系列的数据为该次登录所用，这些数据会在某些指令或某些程序中被使用到。这些数据就称为 Linux Shell 运行时的环境。环境中的数据可以大致分为四种：环境变量，Shell 变量，别名(alias)，Shell 函数。其中 Shell 变量，别名，Shell 函数在此不做详细说明。环境变量里有什么？可以直接用无参...
简单易懂的环境变量设置
qq_52768407的博客
07-20 4130
了解环境变量、如何配置环境变量和一些小技巧等。
getenv putenv setenv和unsetenv详解
暂时为空
02-19 1619
getenv: 定义函数 char * getenv(const char *name); 表头文件 #include  函数说明 getenv()用来取得参数name环境变量的内容。 参数 name为环境变量的名称，如果该变量存在则会返回指向该内容的指针。环境变量的格式为name＝value。
实验四：Linux下进程管道通信.docx
04-13
总结起来，管道通信是操作系统中进程间通信的一个重要方法，它不仅限于父子进程，也可以在有共同祖先的进程之间共享。通过这个实验，我们加深了对管道机制的理解，并学会了如何在实际编程中应用它。
Linux进程间的通信方式和原理
01-27
【Linux进程间的通信方式和原理】 在操作系统中，进程是执行中的程序的实例，拥有自己的内存空间和资源。由于每个进程的用户空间是独立的，所以它们之间不能直接访问对方的数据。然而，为了协同工作，进程间需要...
linux进程间通信管道
01-14
通过学习和实践`pipe_write.c`和`pipe_read.c`，你可以更好地理解命名管道的工作原理及其在Linux进程间通信中的应用。这个知识对于开发多进程应用程序，特别是在系统级编程和网络服务领域，是非常基础且重要的。
linux-linux进程间通信方式汇总.zip
02-26
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程之间共享数据、交换信息的关键技术。本文将全面解析Linux中的各种进程间通信方式，帮助你深入理解这一核心概念。 首先，我们来了解...
进程间软中断通信和管道通信
12-02
为了实现上述的进程间软中断通信和管道通信，开发者需要具备扎实的Linux编程基础，了解信号处理、文件I/O和进程控制等概念。在实际应用中，还需要考虑同步和互斥问题，以避免数据竞争和死锁等并发问题。例如，使用`...
十、进程间通信
Helpsen的博客
03-15 1407
1.什么是进程间通信 Unix/Linux系统中每个进程都拥有独立的4G字节大小的虚拟内存空间。其中高地址的1G字节被映射到相同的物理内存区域，用于保存内核代码和数据。低地址的3G字节作为保存用户代码和数据的用户空间，被映射到彼此不同物理内存。因此同一个虚拟内存地址，在不同的进程中，会被映射到不同的物理内存区域，在多个进程之间以交换虚拟内存地址的方式交换数据是不可能的。鉴于进程之间天然的内存壁垒，为了能够在不同进程之间高效地交换数据，需要有一种专门的机制，这就是所谓的进程间通信(Inter-Process
uc_12_进程间通信IPC_有名管道_无名管道
wwwwood的博客
12-01 958
进程间通信 有名管道 无名管道 管道符 内存壁垒
进程间通信方式
m0_62908071的博客
08-31 114
实现共享内存的整个过程就是按照操作系统的模式来进行的，除此之外，对于该块物理内存空间，其申请和释放也是由操作系统决定的，在建立共享内存时，先要申请空间，再建立映射关系，共享内存任务完成之后，也要先解除映射关系，再释放该物理内存空间。2，共享内存：对于使用共享内存进行通信的两个进程而言，二者都是通过进程结构体、虚拟地址空间、页表映射到物理内存的同一块空间中，而物理内存中的这块空间，就是所谓的在进程间通信时，两个进程都能看到的同一份资源。1，管道通信：管道通信本质上是通过拷贝的方式在进程间实现数据传输。...
getenv的一个坑
friendbaby的专栏
01-28 5155
getenv和setenv这一对，是stdlib中提供的获取和设置当前进程环境变量的函数，我本人也常常使用。 今天写一个小程序，从C#要调用C++的DLL，而C++的代码依赖某一环境变量“MAK_VRLDIR”，相关代码如下： ... const char* vrlDir=getenv("MAK_VRLDIR"); ... 刚开始，我并没有当回事，直接在C#代码中写了如下代码： Sys...
进程环境---getenv、putenv和setenv函数详解
热门推荐
Jayson 博客
12-14 1万+
在Linux中的c程序的典型内存分布中，之前提到的有 text段、data段、bss段、堆和栈这几部分，在笔记“麦子学院c语言->典型c语言程序的c内存分布”中介绍了。但是其实一个c语言进程的内存分布中不止是有这些区域，还有命令行参数、环境变量以及共享库和mmap映射区等区域。如下图所示 ------------------------------ 环境变量区域 命令行参数
Linux下多个命令串联执行(管道/xargs/exec)
Langeldep的专栏
11-08 4030
xargs/exec 组合多个命令
【Linux】进程间通信（IPC）——匿名管道
最新发布
2201_76024104的博客
07-08 1158
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值