Linux环境进程间通信(一) from IBM developerWorks 作者:郑彦兴 (mlinux@163.com)国防科大

[Shell] BrokenPipeError: [Errno 32] Broken pipe1 若 $CLANG_FORMAT_DIFF_SCRIPT 中打印没有执行完时,外面的命令直接重定向或者关闭终端会发生以下错误。BrokenPipeError: 管道重定向导致 stdout 错误。 阅读详情

1、 管道概述及相关API应用

1.1 管道相关的关键概念

管道是Linux支持的最初Unix IPC形式之一,具有以下特点:

  • 管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道;
  • 只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程);
  • 单独构成一种独立的文件系统:管道对于管道两端的进程而言,就是一个文件,但它不是普通的文件,它不属于某种文件系统,而是自立门户,单独构成一种文件系统,并且只存在与内存中。
  • 数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾,并且每次都是从缓冲区的头部读出数据。

1.2管道的创建:

#include <unistd.h>
int pipe(int fd[2])

该函数创建的管道的两端处于一个进程中间,在实际应用中没有太大意义,因此,一个进程在由pipe()创建管道后,一般再fork一个子进程,然后通过管道实现父子进程间的通信(因此也不难推出,只要两个进程中存在亲缘关系,这里的亲缘关系指的是具有共同的祖先,都可以采用管道方式来进行通信)。

1.3管道的读写规则:

管道两端可分别用描述字fd[0]以及fd[1]来描述,需要注意的是,管道的两端是固定了任务的。即一端只能用于读,由描述字fd[0]表示,称其为管道读端;另一端则只能用于写,由描述字fd[1]来表示,称其为管道写端。如果试图从管道写端读取数据,或者向管道读端写入数据都将导致错误发生。一般文件的I/O函数都可以用于管道,如close、read、write等等。

从管道中读取数据:

  • 如果管道的写端不存在,则认为已经读到了数据的末尾,读函数返回的读出字节数为0;
  • 当管道的写端存在时,如果请求的字节数目大于PIPE_BUF,则返回管道中现有的数据字节数,如果请求的字节数目不大于PIPE_BUF,则返回管道中现有数据字节数(此时,管道中数据量小于请求的数据量);或者返回请求的字节数(此时,管道中数据量不小于请求的数据量)。注:(PIPE_BUF在include/linux/limits.h中定义,不同的内核版本可能会有所不同。Posix.1要求PIPE_BUF至少为512字节,red hat 7.2中为4096)。

关于管道的读规则验证:

 /**************
 * readtest.c *
 **************/
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
main()
{
	int pipe_fd[2];
	pid_t pid;
	char r_buf[100];
	char w_buf[4];
	char* p_wbuf;
	int r_num;
	int cmd;
	
	memset(r_buf,0,sizeof(r_buf));
	memset(w_buf,0,sizeof(r_buf));
	p_wbuf=w_buf;
	if(pipe(pipe_fd)<0)
	{
		printf("pipe create error\n");
		return -1;
	}
	
	if((pid=fork())==0)
	{
		printf("\n");
		close(pipe_fd[1]);
		sleep(3);//确保父进程关闭写端
	    r_num=read(pipe_fd[0],r_buf,100);
printf(	"read num is %d   the data read from the pipe is %d\n",r_num,atoi(r_buf));
		
		close(pipe_fd[0]);
		exit();
	}
	else if(pid>0)
	{
	close(pipe_fd[0]);//read
	strcpy(w_buf,"111");
	if(write(pipe_fd[1],w_buf,4)!=-1)
		printf("parent write over\n");
	close(pipe_fd[1]);//write
		printf("parent close fd[1] over\n");
	sleep(10);
	}	
}
 /**************************************************
 * 程序输出结果:
 * parent write over
 * parent close fd[1] over
 * read num is 4   the data read from the pipe is 111
 * 附加结论:
 * 管道写端关闭后,写入的数据将一直存在,直到读出为止.
 ****************************************************/ 
 

向管道中写入数据:

  • 向管道中写入数据时,linux将不保证写入的原子性,管道缓冲区一有空闲区域,写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据,那么写操作将一直阻塞。 
    注:只有在管道的读端存在时,向管道中写入数据才有意义。否则,向管道中写入数据的进程将收到内核传来的SIFPIPE信号,应用程序可以处理该信号,也可以忽略(默认动作则是应用程序终止)。

对管道的写规则的验证1:写端对读端存在的依赖性

#include <unistd.h>
#include <sys/types.h>
main()
{
	int pipe_fd[2];
	pid_t pid;
	char r_buf[4];
	char* w_buf;
	int writenum;
	int cmd;
	
	memset(r_buf,0,sizeof(r_buf));
	if(pipe(pipe_fd)<0)
	{
		printf("pipe create error\n");
		return -1;
	}
	
	if((pid=fork())==0)
	{
		close(pipe_fd[0]);
		close(pipe_fd[1]);
		sleep(10);	
		exit();
	}
	else if(pid>0)
	{
	sleep(1);  //等待子进程完成关闭读端的操作
	close(pipe_fd[0]);//write
	w_buf="111";
	if((writenum=write(pipe_fd[1],w_buf,4))==-1)
		printf("write to pipe error\n");
	else	
		printf("the bytes write to pipe is %d \n", writenum);
	
	close(pipe_fd[1]);
	}	
}

则输出结果为: Broken pipe,原因就是该管道以及它的所有fork()产物的读端都已经被关闭。如果在父进程中保留读端,即在写完pipe后,再关闭父进程的读端,也会正常写入pipe,读者可自己验证一下该结论。因此,在向管道写入数据时,至少应该存在某一个进程,其中管道读端没有被关闭,否则就会出现上述错误(管道断裂,进程收到了SIGPIPE信号,默认动作是进程终止)

对管道的写规则的验证2:linux不保证写管道的原子性验证

#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
main(int argc,char**argv)
{
	int pipe_fd[2];
	pid_t pid;
	char r_buf[4096];
	char w_buf[4096*2];
	int writenum;
	int rnum;
	memset(r_buf,0,sizeof(r_buf));	
	if(pipe(pipe_fd)<0)
	{
		printf("pipe create error\n");
		return -1;
	}
	
	if((pid=fork())==0)
	{
		close(pipe_fd[1]);
		while(1)
		{
		sleep(1);	
		rnum=read(pipe_fd[0],r_buf,1000);
		printf("child: readnum is %d\n",rnum);
		}
		close(pipe_fd[0]);
		
		exit();
	}
	else if(pid>0)
	{
	close(pipe_fd[0]);//write
	memset(r_buf,0,sizeof(r_buf));	
	if((writenum=write(pipe_fd[1],w_buf,1024))==-1)
		printf("write to pipe error\n");
	else	
		printf("the bytes write to pipe is %d \n", writenum);
	writenum=write(pipe_fd[1],w_buf,4096);
	close(pipe_fd[1]);
	}	
}
输出结果:
the bytes write to pipe 1000
the bytes write to pipe 1000  //注意,此行输出说明了写入的非原子性
the bytes write to pipe 1000
the bytes write to pipe 1000
the bytes write to pipe 1000
the bytes write to pipe 120  //注意,此行输出说明了写入的非原子性
the bytes write to pipe 0
the bytes write to pipe 0
......

结论:

写入数目小于4096时写入是非原子的! 
如果把父进程中的两次写入字节数都改为5000,则很容易得出下面结论: 
写入管道的数据量大于4096字节时,缓冲区的空闲空间将被写入数据(补齐),直到写完所有数据为止,如果没有进程读数据,则一直阻塞。

1.4管道应用实例:

实例一:用于shell

管道可用于输入输出重定向,它将一个命令的输出直接定向到另一个命令的输入。比如,当在某个shell程序(Bourne shell或C shell等)键入who│wc -l后,相应shell程序将创建who以及wc两个进程和这两个进程间的管道。考虑下面的命令行:

$kill -l 运行结果见 附一。

$kill -l | grep SIGRTMIN 运行结果如下:

30) SIGPWR	31) SIGSYS	32) SIGRTMIN	33) SIGRTMIN+1
34) SIGRTMIN+2	35) SIGRTMIN+3	36) SIGRTMIN+4	37) SIGRTMIN+5
38) SIGRTMIN+6	39) SIGRTMIN+7	40) SIGRTMIN+8	41) SIGRTMIN+9
42) SIGRTMIN+10	43) SIGRTMIN+11	44) SIGRTMIN+12	45) SIGRTMIN+13
46) SIGRTMIN+14	47) SIGRTMIN+15	48) SIGRTMAX-15	49) SIGRTMAX-14

实例二:用于具有亲缘关系的进程间通信

下面例子给出了管道的具体应用,父进程通过管道发送一些命令给子进程,子进程解析命令,并根据命令作相应处理。

#include <unistd.h>
#include <sys/types.h>
main()
{
	int pipe_fd[2];
	pid_t pid;
	char r_buf[4];
	char** w_buf[256];
	int childexit=0;
	int i;
	int cmd;
	
	memset(r_buf,0,sizeof(r_buf));
	if(pipe(pipe_fd)<0)
	{
		printf("pipe create error\n");
		return -1;
	}
	if((pid=fork())==0)
	//子进程:解析从管道中获取的命令,并作相应的处理
	{
		printf("\n");
		close(pipe_fd[1]);
		sleep(2);
		
		while(!childexit)
		{	
			read(pipe_fd[0],r_buf,4);
			cmd=atoi(r_buf);
			if(cmd==0)
			{
printf("child: receive command from parent over\n now child process exit\n");
				childexit=1;
			}
			
		       else if(handle_cmd(cmd)!=0)
				return;
			sleep(1);
		}
		close(pipe_fd[0]);
		exit();
	}
	else if(pid>0)
	//parent: send commands to child
	{
	close(pipe_fd[0]);
	w_buf[0]="003";
	w_buf[1]="005";
	w_buf[2]="777";
	w_buf[3]="000";
	for(i=0;i<4;i++)
		write(pipe_fd[1],w_buf[i],4);
	close(pipe_fd[1]);
	}	
}
//下面是子进程的命令处理函数(特定于应用):
int handle_cmd(int cmd)
{
if((cmd<0)||(cmd>256))
//suppose child only support 256 commands
	{
	printf("child: invalid command \n");
	return -1;
	}
printf("child: the cmd from parent is %d\n", cmd);
return 0;
}

1.5管道的局限性

管道的主要局限性正体现在它的特点上:

  • 只支持单向数据流;
  • 只能用于具有亲缘关系的进程之间;
  • 没有名字;
  • 管道的缓冲区是有限的(管道制存在于内存中,在管道创建时,为缓冲区分配一个页面大小);
  • 管道所传送的是无格式字节流,这就要求管道的读出方和写入方必须事先约定好数据的格式,比如多少字节算作一个消息(或命令、或记录)等等;

2、 有名管道概述及相关API应用

2.1 有名管道相关的关键概念

管道应用的一个重大限制是它没有名字,因此,只能用于具有亲缘关系的进程间通信,在有名管道(named pipe或FIFO)提出后,该限制得到了克服。FIFO不同于管道之处在于它提供一个路径名与之关联,以FIFO的文件形式存在于文件系统中。这样,即使与FIFO的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过FIFO相互通信(能够访问该路径的进程以及FIFO的创建进程之间),因此,通过FIFO不相关的进程也能交换数据。值得注意的是,FIFO严格遵循先进先出(first in first out),对管道及FIFO的读总是从开始处返回数据,对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。

2.2有名管道的创建

#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char * pathname, mode_t mode)

该函数的第一个参数是一个普通的路径名,也就是创建后FIFO的名字。第二个参数与打开普通文件的open()函数中的mode 参数相同。 如果mkfifo的第一个参数是一个已经存在的路径名时,会返回EEXIST错误,所以一般典型的调用代码首先会检查是否返回该错误,如果确实返回该错误,那么只要调用打开FIFO的函数就可以了。一般文件的I/O函数都可以用于FIFO,如close、read、write等等。

2.3有名管道的打开规则

有名管道比管道多了一个打开操作:open。

FIFO的打开规则:

如果当前打开操作是为读而打开FIFO时,若已经有相应进程为写而打开该FIFO,则当前打开操作将成功返回;否则,可能阻塞直到有相应进程为写而打开该FIFO(当前打开操作设置了阻塞标志);或者,成功返回(当前打开操作没有设置阻塞标志)。

如果当前打开操作是为写而打开FIFO时,如果已经有相应进程为读而打开该FIFO,则当前打开操作将成功返回;否则,可能阻塞直到有相应进程为读而打开该FIFO(当前打开操作设置了阻塞标志);或者,返回ENXIO错误(当前打开操作没有设置阻塞标志)。

对打开规则的验证参见 附2。

2.4有名管道的读写规则

从FIFO中读取数据:

约定:如果一个进程为了从FIFO中读取数据而阻塞打开FIFO,那么称该进程内的读操作为设置了阻塞标志的读操作。

  • 如果有进程写打开FIFO,且当前FIFO内没有数据,则对于设置了阻塞标志的读操作来说,将一直阻塞。对于没有设置阻塞标志读操作来说则返回-1,当前errno值为EAGAIN,提醒以后再试。
  • 对于设置了阻塞标志的读操作说,造成阻塞的原因有两种:当前FIFO内有数据,但有其它进程在读这些数据;另外就是FIFO内没有数据。解阻塞的原因则是FIFO中有新的数据写入,不论信写入数据量的大小,也不论读操作请求多少数据量。
  • 读打开的阻塞标志只对本进程第一个读操作施加作用,如果本进程内有多个读操作序列,则在第一个读操作被唤醒并完成读操作后,其它将要执行的读操作将不再阻塞,即使在执行读操作时,FIFO中没有数据也一样(此时,读操作返回0)。
  • 如果没有进程写打开FIFO,则设置了阻塞标志的读操作会阻塞。

注:如果FIFO中有数据,则设置了阻塞标志的读操作不会因为FIFO中的字节数小于请求读的字节数而阻塞,此时,读操作会返回FIFO中现有的数据量。

向FIFO中写入数据:

约定:如果一个进程为了向FIFO中写入数据而阻塞打开FIFO,那么称该进程内的写操作为设置了阻塞标志的写操作。

对于设置了阻塞标志的写操作:

  • 当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数,则进入睡眠,直到当缓冲区中能够容纳要写入的字节数时,才开始进行一次性写操作。
  • 当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域,写进程就会试图向管道写入数据,写操作在写完所有请求写的数据后返回。

对于没有设置阻塞标志的写操作:

  • 当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后,写操作返回。
  • 当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数,写完后成功返回;如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数,则返回EAGAIN错误,提醒以后再写;

对FIFO读写规则的验证:

下面提供了两个对FIFO的读写程序,适当调节程序中的很少地方或者程序的命令行参数就可以对各种FIFO读写规则进行验证。


程序1:写FIFO的程序
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#define FIFO_SERVER "/tmp/fifoserver"
main(int argc,char** argv)
//参数为即将写入的字节数
{
	int fd;
	char w_buf[4096*2];
	int real_wnum;
	memset(w_buf,0,4096*2);
	if((mkfifo(FIFO_SERVER,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))
		printf("cannot create fifoserver\n");
	if(fd==-1)
		if(errno==ENXIO)
			printf("open error; no reading process\n");
		
     	fd=open(FIFO_SERVER,O_WRONLY|O_NONBLOCK,0);
	//设置非阻塞标志
	//fd=open(FIFO_SERVER,O_WRONLY,0);
	//设置阻塞标志
	real_wnum=write(fd,w_buf,2048);
	if(real_wnum==-1)
	{
		if(errno==EAGAIN)
			printf("write to fifo error; try later\n");
	}
	else 
		printf("real write num is %d\n",real_wnum);
	real_wnum=write(fd,w_buf,5000);
	//5000用于测试写入字节大于4096时的非原子性
	//real_wnum=write(fd,w_buf,4096);
	//4096用于测试写入字节不大于4096时的原子性
	
	if(real_wnum==-1)
		if(errno==EAGAIN)
			printf("try later\n");
}


程序2:与程序1一起测试写FIFO的规则,第一个命令行参数是请求从FIFO读出的字节数
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#define FIFO_SERVER "/tmp/fifoserver"
main(int argc,char** argv)
{
	char r_buf[4096*2];
	int  fd;
	int  r_size;
	int  ret_size;
	r_size=atoi(argv[1]);
	printf("requred real read bytes %d\n",r_size);
	memset(r_buf,0,sizeof(r_buf));
	fd=open(FIFO_SERVER,O_RDONLY|O_NONBLOCK,0);
	//fd=open(FIFO_SERVER,O_RDONLY,0);
	//在此处可以把读程序编译成两个不同版本:阻塞版本及非阻塞版本
	if(fd==-1)
	{
		printf("open %s for read error\n");
		exit();	
	}
	while(1)
	{
		
		memset(r_buf,0,sizeof(r_buf));
		ret_size=read(fd,r_buf,r_size);
		if(ret_size==-1)
			if(errno==EAGAIN)
				printf("no data avlaible\n");
		printf("real read bytes %d\n",ret_size);
		sleep(1);
	}	
	pause();
	unlink(FIFO_SERVER);
}

程序应用说明:

把读程序编译成两个不同版本:

  • 阻塞读版本:br
  • 以及非阻塞读版本nbr

把写程序编译成两个四个版本:

  • 非阻塞且请求写的字节数大于PIPE_BUF版本:nbwg
  • 非阻塞且请求写的字节数不大于PIPE_BUF版本:版本nbw
  • 阻塞且请求写的字节数大于PIPE_BUF版本:bwg
  • 阻塞且请求写的字节数不大于PIPE_BUF版本:版本bw

下面将使用br、nbr、w代替相应程序中的阻塞读、非阻塞读

验证阻塞写操作:

  1. 当请求写入的数据量大于PIPE_BUF时的非原子性:
    • nbr 1000
    • bwg
  2. 当请求写入的数据量不大于PIPE_BUF时的原子性:
    • nbr 1000
    • bw

验证非阻塞写操作:

  1. 当请求写入的数据量大于PIPE_BUF时的非原子性:
    • nbr 1000
    • nbwg
  2. 请求写入的数据量不大于PIPE_BUF时的原子性:
    • nbr 1000
    • nbw

不管写打开的阻塞标志是否设置,在请求写入的字节数大于4096时,都不保证写入的原子性。但二者有本质区别:

对于阻塞写来说,写操作在写满FIFO的空闲区域后,会一直等待,直到写完所有数据为止,请求写入的数据最终都会写入FIFO;

而非阻塞写则在写满FIFO的空闲区域后,就返回(实际写入的字节数),所以有些数据最终不能够写入。

对于读操作的验证则比较简单,不再讨论。

2.5有名管道应用实例

在验证了相应的读写规则后,应用实例似乎就没有必要了。

小结:

管道常用于两个方面:(1)在shell中时常会用到管道(作为输入输入的重定向),在这种应用方式下,管道的创建对于用户来说是透明的;(2)用于具有亲缘关系的进程间通信,用户自己创建管道,并完成读写操作。

FIFO可以说是管道的推广,克服了管道无名字的限制,使得无亲缘关系的进程同样可以采用先进先出的通信机制进行通信。

管道和FIFO的数据是字节流,应用程序之间必须事先确定特定的传输"协议",采用传播具有特定意义的消息。

要灵活应用管道及FIFO,理解它们的读写规则是关键。

附1:kill -l 的运行结果,显示了当前系统支持的所有信号:

1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL
5) SIGTRAP	 6) SIGABRT	 7) SIGBUS	 8) SIGFPE
9) SIGKILL	10) SIGUSR1	11) SIGSEGV	12) SIGUSR2
13) SIGPIPE	14) SIGALRM	15) SIGTERM	17) SIGCHLD
18) SIGCONT	19) SIGSTOP	20) SIGTSTP	21) SIGTTIN
22) SIGTTOU	23) SIGURG	24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO
30) SIGPWR	31) SIGSYS	32) SIGRTMIN	33) SIGRTMIN+1
34) SIGRTMIN+2	35) SIGRTMIN+3	36) SIGRTMIN+4	37) SIGRTMIN+5
38) SIGRTMIN+6	39) SIGRTMIN+7	40) SIGRTMIN+8	41) SIGRTMIN+9
42) SIGRTMIN+10	43) SIGRTMIN+11	44) SIGRTMIN+12	45) SIGRTMIN+13
46) SIGRTMIN+14	47) SIGRTMIN+15	48) SIGRTMAX-15	49) SIGRTMAX-14
50) SIGRTMAX-13	51) SIGRTMAX-12	52) SIGRTMAX-11	53) SIGRTMAX-10
54) SIGRTMAX-9	55) SIGRTMAX-8	56) SIGRTMAX-7	57) SIGRTMAX-6
58) SIGRTMAX-5	59) SIGRTMAX-4	60) SIGRTMAX-3	61) SIGRTMAX-2
62) SIGRTMAX-1	63) SIGRTMAX	

除了在此处用来说明管道应用外,接下来的专题还要对这些信号分类讨论。

附2:对FIFO打开规则的验证(主要验证写打开对读打开的依赖性)

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#define FIFO_SERVER "/tmp/fifoserver"
int handle_client(char*);
main(int argc,char** argv)
{
	int r_rd;
	int w_fd;
	pid_t pid;
	if((mkfifo(FIFO_SERVER,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))
		printf("cannot create fifoserver\n");
	handle_client(FIFO_SERVER);
	
}
int handle_client(char* arg)
{
int ret;
ret=w_open(arg);
switch(ret)
{
	case 0:
	{	
	printf("open %s error\n",arg);
	printf("no process has the fifo open for reading\n");
	return -1;
	}
	case -1:
	{
		printf("something wrong with open the fifo except for ENXIO");
		return -1;
	}
	case 1:
	{
		printf("open server ok\n");
		return 1;
	}
	default:
	{
		printf("w_no_r return ----\n");
		return 0;
	}
}		
unlink(FIFO_SERVER);
}
int w_open(char*arg)
//0  open error for no reading
//-1 open error for other reasons
//1  open ok
{
	if(open(arg,O_WRONLY|O_NONBLOCK,0)==-1)
	{	if(errno==ENXIO)
		{
			return 0;
		}
		else
		return -1;
	}
	return 1;
	
}

车机破解避坑指南:为什么你的CarPlay盒子不识别?从USB设备ID解析兼容性问题 本文深入解析车机USB设备兼容性问题,特别是CarPlay盒子不识别的原因,从硬件ID到识别机制全面剖析。通过ADB工具和root权限操作,提供详细的破解方案和兼容性测试结果,帮助用户解决车机与第三方设备的连接问题。 阅读详情

相关推荐

LPDDR5时序精调:深入解析Read Gate Training的两种模式

本文深入解析了LPDDR5内存中关键的Read Gate Training技术,详细对比了RDQS Toggle Mode(翻转模式)与Enhanced RDQS Mode(增强模式)的工作原理、时序参数及适用场景。文章阐述了在高速数据传输下精准校准时序的必要性,并提供了两种模式的实战选型指南与系统级调试思路,帮助工程师优化内存性能与稳定性。

weixin_29219189的博客 369

linux:shell编程遇到一个问题:sort: write failed: standard output: Broken pipe

产生的原因:是由于sort与head这个参数一起使用了,所以导致了这样的事情发生。 例如:cat message.txt| sort -nrk 3 |head -n 10这个命令执行过后就会有上面的错误发生 sort| head总是报告一个错误,如果在sort写入所有输出之前head退出(或者以其他方式关闭它的stdin)(如果由sort写入的流比head消耗的流长得多)。 这是按设计的:如果so...

一直在路上的羊的博客 5556

Flocking for Multi-Agent Dynamic Systems: Algorithms and Theory的理论简述和python仿真实现(附源码)

经典论文Flocking for Multi-Agent Dynamic Systems: Algorithms and Theory的学习与编程仿真,提供源码

m0_59701926的博客 1239

Linux环境进程间通信(一): 管道及有名管道

Linux环境进程间通信(一): 管道及有名管道 内容:管道概述及相关API应用有名管道概述及相关API应用小结参考资料关于作者相关内容:介绍介绍-->在 Linux 专区还有:

Sah的Blog搬家了!新地址为:sah-lee.51.net 2043

基于Android Studio的校园智能点餐系统开发实战(附完整源码与部署指南)

本文详细介绍了基于Android Studio开发校园智能点餐系统的完整流程,包括需求分析、环境搭建、数据库设计、客户端与后台功能实现。系统采用SSM框架和MySQL数据库,解决了校园食堂高峰期排队问题,提供高效的点餐体验。附完整源码与部署指南,助力开发者快速构建类似应用。

weixin_29015801的博客 563

timing window file中的S L T指什么意思

我正在「拾陆楼」和朋友们讨论有趣的话题,你⼀起来吧?

m0_61544122的博客 778

linux shell - broken pip error

【基本介绍】 这里我们介绍发生broken pipe错误的原因以及解决方案。 【broken pip error】 例如:svn log svn://xxxx | head -10 这样bash在执行的svn log svn://xxxx的时候起一个线程1,在执行head -10的时候起一个线程2。两个线程同时运行。线程2读到第10行的时候退出,然后关闭管道。但是线程1还在跑,继续往管...

飞奔的熊猫 1269

数据挖掘实战-基于KMeans算法对超市客户进行聚类分群

本实验基于KMeans算法对超市客户进行了聚类分群。通过对客户购物数据进行聚类,我们成功将客户分为不同的群体。每个群体代表了具有相似购物行为和偏好的客户群体。通过实验结果,我们发现了客户群体之间的明显差异和共性。不同群体的客户在购买频率、购物金额和购买种类等方面有所区别。这为超市提供了重要的市场细分信息,帮助超市经营者更好地了解不同客户群体的需求和喜好,制定有针对性的营销策略和商品推荐,提高客户满意度和忠诚度。此外,实验还揭示了超市客户的购物行为规律,为超市优化商品陈列和促销策略提供了指导。

m0_64336780的博客 2万+

shell报错【sort: write failed: standard output: Broken pipe】的终极解决方案❤

出现这个报错【sort: write failed: standard output: Broken pipe】后找了半天没找到解决方案,后面终于在这位大佬的博客找到终极方案。也就是直接把`tail -n 1`修改为`sed -n 1p`,程序就正常运行了。

NCU_Good的博客 1017

机器学习笔记——30种常见机器学习算法简要汇总

本笔记介绍机器学习中常见的30种机器学习算法。

haopinglianlian的博客 3202

YOLOv11【第二十章:模型迭代与生态闭环篇·第1节】在线增量学习——部署后新数据自动回流重训!

🏆 本文收录于专栏 《YOLOv11实战:从入门到深度优化》。本专栏围绕 YOLOv11 的改进、训练、部署与工程优化 展开,系统梳理并复现当前主流的 YOLOv11 实战案例与优化方案,内容目前已覆盖 分类、检测、分割、追踪、关键点、OBB 检测 等多个方向。

**My Coding Family** 434

C语言第四章(进程间的通信,管道通信,pipe()函数)

本文讲解的是C语言的进程之间的通信,这里讲解的是管道通信,和相关的函数pipe().

jakelihua 3411

无人机导航中的坐标系统详解与转换实现

本文系统介绍了无人机导航中常用的坐标系及其转换方法。主要内容包括:1) 四种关键坐标系(大地坐标系ECEF、经纬度LLA、北东天坐标系NED、机体坐标系)的定义和特点;2) 坐标系间的转换原理与实现,重点讲解LLA与ECEF的互转公式及ECEF与NED的转换方法;3) 提供可直接使用的C++实现代码,包括基于WGS84椭球模型的精确转换算法。这些内容为无人机导航系统开发提供了实用的坐标系处理方案,能够有效解决多源数据在不同坐标系下的统一表示问题。

电脑管家 380

Linux环境进程间通信(二上) from IBM developerWorks 作者:郑彦兴 (mlinux@163.com)国防科大

一、信号及信号来源 信号本质 信号是在软件层次上对中断机制的一种模拟,在原理上,一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的,一个进程不必通过任何操作来等待信号的到达,事实上,进程也不知道信号到底什么时候到达。 信号是进程间通信机制中唯一的异步通信机制,可以看作是异步通知,通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后,功能更加强

Inter-Process Communication 3226

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Linux环境进程间通信(二下) from IBM developerWorks 作者:郑彦兴 (mlinux@163.com)国防科大

一、信号生命周期 从信号发送到信号处理函数的执行完毕 对于一个完整的信号生命周期(从信号发送到相应的处理函数执行完毕)来说,可以分为三个重要的阶段,这三个阶段由四个重要事件来刻画:信号诞生;信号在进程中注册完毕;信号在进程中的注销完毕;信号处理函数执行完毕。相邻两个事件的时间间隔构成信号生命周期的一个阶段。   下面阐述四个事件的实际意义: 信号"诞生"。信号的诞

Inter-Process Communication 3203

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Linux环境进程间通信(三) from IBM developerWorks 作者:郑彦兴 (mlinux@163.com)国防科大

消息队列(也叫做报文队列)能够克服早期unix通信机制的一些缺点。作为早期unix通信机制之一的信号能够传送的信息量有限,后来虽然POSIX 1003.1b在信号的实时性方面作了拓广,使得信号在传递信息量方面有了相当程度的改进,但是信号这种通信方式更像"即时"的通信方式,它要求接受信号的进程在某个时间范围内对信号做出反应,因此该信号最多在接受信号进程的生命周期内才有意义,信号所传递的信息是接近于随

Inter-Process Communication 3238

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Linux下shell程序报cat写入错误:断开的管道

linux下shell程序运行,出现断开的管道错误问题分析及处理。

weixin_38980630的博客 1450

Linux系统排错

一、修复446字节的grub2数据损坏: 破坏过程: dd  if=/dev/zero  of=/dev/vda  bs=446  count=1 reboot 重启后无法登陆系统 修复过程: 关闭虚拟机,使用相应版本的iso镜像通过光驱进行系统修复 添加光驱,选择iso镜像路径,finish 设置boot options,将启动顺序调整为光驱优先,打开虚拟机 选...

moxiliushui的博客 768

LinuxC 进程间通信 --- 管道

这样,即使与FIFO的创建进程不存在亲缘关系的进程,只要可以访问该路径,就能够彼此通过FIFO相互通信(能够访问该路径的进程以及FIFO的创建进程之间),因此,通过FIFO不相关的进程也能交换数据。1、写管道时,如果管道的读端被close了话,向管道“写”数据的进程会被内核发送一个SIGPIPE信号, 发这个信号的目的就是想通知你,管道所有的“读”都被关闭了。1、为了保证管道一定被创建,最好是两个进程都包含创建管道的代码,谁先运行就谁先创建,后运行的发现管道已经创建好了,那就直接open打开使用。

weixin_44977283的博客 220

【Linux】信号

SIGPIPESIGCHLD SIGPIPE 网络程序必须要处理SIGPIPE信号,否则当客户端推出后,服务器仍然向该SOCKET发送信号,则会引起崩溃 SIGCHLD 这个信号处理不当的话,会产生僵尸进程,影响服务器性能 僵尸进程是一个早已死亡的进程,但在进程表中仍占有位置 Linux中当子进程结束时,它并没有完全被销毁,因为父进程还要用到它的信息 当子进程结束时会发送SIGCHLD信号,若父进程没有处理这个信号,或调用 wait/waitpid() 等待子进程结束,就会产生僵尸进程 更多Linux信号.

Hello,My Friends~ 368

C语言 pipe

每个进程拥有各自的地址空间,一个进程的全局变量在另一个进程中看不到,所以进程之间不能相互访问,要交换数据必须经过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信(IPC,InterProcess Communication)。 常用的IPC方法有: pipe管道 (使用最简单) fifo信号 (开销最小) mmap...

Claroja 1505

Linux关于管道

管道的概念 管道是Unix中最古老的进程间通信的形式。 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道” 我们通常把是把一个进程的输出连接或“管接”(经过管道来连接)到另一个进程的输入。 管道特点 管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道 只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程)进行通信;通常,一个管道由一个进程创建,然后该进程调用...

Gaodes的博客 622

(Linux)TCP实现服务器和客户端通信+详细注释

2.connect函数表示连接到服务器,这个函数将套接字连接到 sockaddr_in 结构体中描述的IP地址和端口号,如果连接失败,将返回一个负数值。该程序实现了一个简单的TCP服务器的功能,可以接收客户端的连接,并且循环接收客户端发送的消息,将接收到的消息输出到终端。这是一个TCP客户端代码,它的主要功能是连接到指定的服务器,并且有发送消息接收消息的功能。5.在一个while循环中循环接收客户端发送的消息,然后将接收到的消息输出到终端。1.使用socket函数创建一个IPv4的TCP套接字。

qq_58220428的博客 1048

C语言练手项目--C 语言编写聊天室

C 语言编写聊天室一、需求二、知识点1、TCP/IP协议2、文件操作3、数据库三、实现1、思路2、代码3、运行结果四、参考 一、需求 基于TCP编写,一个聊天室最多100人。 客户端: 1、用户需要登录,登录时只需要输入一个昵称即可无需判断昵称是否重复(如果其他功能都ok考虑) 2、用户登录后连接服务器端,进入聊天室 3、用户可以输入聊天信息,也可以收到别人的聊天信息。 4、用户可以用某个...

天道酬勤 1万+

Linux网络编程实现客户端服务端收发数据功能

客户端代码 #include #include #include #include #include #include #include #include int main(void) { int st = socket(AF_INET, SOCK_STREAM, 0);//初始化socket struct sockaddr_in addr; // 定义一个IP地址的结构

HelloNiGeSB的博客 2403

6.29 作业

使用管道实现AB两个进程的相互通信(提示:每个程序都可以使用多进程、多线程)

Remi____的博客 277
上一篇: wiki上IPC解释
下一篇: Linux环境进程间通信(二上) from IBM developerWorks 作者:郑彦兴 (mlinux@163.com)国防科大
wgj1922
博客等级 码龄23年 0粉丝 0原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值