IPC之FIFO

最新推荐文章于 2021-09-16 15:50:28 发布
最新推荐文章于 2021-09-16 15:50:28 发布
阅读量665 收藏
点赞数
分类专栏： Linux C 文章标签： linux c ipc FIFO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tj807126663/article/details/26404637
版权

简介

             FIFO又被称为命名管道，它是一种特殊类型的文件，它在文件系统中以文件名的形式存在，一般的文件I/O函数都可以用于FIFO。

        打开一个FIFO时，非阻塞标志(O_NONBLOCK)产生下列影响：

    • 未指定O_NONBLOCK

        只读open()要阻塞到某个其他进程为写而打开此FIFO。类似的，只写open()要阻塞到某个其他进程为读而打开它。

    • 指定O_NONBLOCK

        只读open()立即返回。但是，如果没有进程已经为读而打开一个FIFO，那么只写open()将出错返回-1，其errno是ENXIO。

        基于O_NONBLOCK对FIFO操作的影响，一种比较好的操作FIFO的方式是以非阻塞的方式打开文件，然后以阻塞的方式读写文件或使用select。

        一个给定的FIFO有多个写进程是很常见的。这意味着如果不希望多个进程写的数据互相穿插，则需考虑原子操作，常量PIPE_BUF说明了可被原子地写到FIFO的最大数据量。

        FIFO有以下两种用途：

    1.     FIFO由shell命令使用以便将数据从一条管道线传送到另一条，为此不需要创建中间临时文件。
    2.     FIFO用于客户进程-服务器进程的应用程序中，以在客户进程和服务器进程中传递数据。


示例程序

阻塞版本


服务端

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

#define RECV_BUF_SIZE 1024
#define SEND_BUF_SIZE 1024
#define CONTENT_LEN 128
#define ARGUMENT_LEN 128

#define DATA_SEPARATOR ':'
#define SERVER_FIFO_PATH "/tmp/fifo_server"

int 	server_write_fd, server_read_fd, client_write_fd;
char    send_buf[SEND_BUF_SIZE];
char	content[CONTENT_LEN];
char	client_fifo_path[ARGUMENT_LEN];
char    recv_buf[RECV_BUF_SIZE];
char    send_buf[SEND_BUF_SIZE];

static int  fifo_mode = S_IRUSR| S_IWUSR| S_IRGRP| S_IWGRP;

/*
 * create server fifo
 * success : 0 failed : -1
 */
int fifo_init(void)
{
	int 		ret;
	struct stat filestat;


	ret = stat(SERVER_FIFO_PATH, &filestat);
	if(ret == 0){
		if (unlink(SERVER_FIFO_PATH) < 0){
			perror("Cannot delete old MI fifo");
			return -1;
		}
	}else if(ret < 0 && errno != ENOENT){
		perror("MI FIFO stat failed");
		return -1;
	}

    if((mkfifo(SERVER_FIFO_PATH, fifo_mode) < 0)){
        perror("Create client fifo error");
      	return -1; 
    }

    if((chmod(SERVER_FIFO_PATH, fifo_mode) < 0)){
        perror("Chmod client fifo error");
		goto error;
    }

	return 0;

error:
   	remove(SERVER_FIFO_PATH);
	return -1;
		
}

/*
 * open server fifo
 * success : fd failed : -1
 */
int open_client_fifo(char *pipe_name)
{
    int     flags;

    if(!pipe_name || *pipe_name == 0){
        printf("No server fifo to open\n");
        return -1;
    }

    client_write_fd = open(pipe_name, O_WRONLY|O_NONBLOCK);
    if(client_write_fd < 0){
        perror("Can't open server fifo error");
        return -1;
    }

    if((flags = fcntl(client_write_fd, F_GETFL, 0)) < 0){
        perror("Server fifo F_GETFL error");
        goto error;
    }

    flags&=~O_NONBLOCK;

    if(fcntl(client_write_fd, F_SETFL, flags) < 0){
        perror("Server fifo F_GETFL error");
        goto error;
    }

    return 0;

error:
    close(client_write_fd);
    return -1;
}

/*
 * open server  fifo for reading
 * success : fd failed : -1
 */
int open_server_fifo(char * pipe_name)
{
    int     flags;

    if(!pipe_name || *pipe_name == 0){
        printf("No client fifo to open");
        return -1;
    }

    server_read_fd = open(pipe_name, O_RDONLY|O_NONBLOCK);
    if(server_read_fd < 0){
        printf("Can't open client fifo for reading");
        return -1;
    }

    server_write_fd = open(pipe_name, O_WRONLY|O_NONBLOCK);
    if(server_write_fd < 0){
        printf("Can't open client fifo for writing");
        return -1;
    }

    if((flags = fcntl(server_read_fd, F_GETFL, 0)) < 0){
        printf("Client fifo F_GETFL error");
        goto error;
    }

    flags&=~O_NONBLOCK;

    if(fcntl(server_read_fd, F_SETFL, flags) < 0){
        printf("Client fifo F_SETFL error");
        goto error;
    }

    return 0;

error:
    close(server_read_fd);
    close(server_write_fd);
    return -1;
}

int data_parse(void)
{
	char	*p, *postion;
	
	p = recv_buf;


	if(*p != DATA_SEPARATOR){
		printf("command must begin with %c\n", DATA_SEPARATOR);
		return -1;
	}
	p++;

	postion = strchr(p, DATA_SEPARATOR);
	if(postion == NULL){
		printf("file separator missing in fifo command\n");
		return -1;
	}
	strncpy(client_fifo_path, p, postion - p);

	p = ++postion;
	strncpy(content, p, strlen(p));

	return 0;
}

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

    int     ret;

    if(fifo_init()){
		return -1;
    }

    if(open_server_fifo(SERVER_FIFO_PATH)){
		goto error;
    }

   	while(1){
		memset(recv_buf, 0, RECV_BUF_SIZE);
		if((ret = read(server_read_fd, recv_buf, RECV_BUF_SIZE)) > 0){

			if(data_parse()){
				continue;
			}
			printf("Receive data from <%s> : %s\n",
					client_fifo_path, content);

    		if(open_client_fifo(client_fifo_path)){
				continue;
    		}

			sprintf(send_buf, "hello, %s\n", client_fifo_path);
			ret = write(client_write_fd, send_buf, strlen(send_buf));
			if(ret < 0){
				perror("Write data to client fifo error");
				continue;
			}
		}
	}

	exit(EXIT_SUCCESS);

error:
	remove(SERVER_FIFO_PATH);
	exit(EXIT_FAILURE);
}

客户端

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

#define SERVER_FIFO_PATH "/tmp/fifo_server"
#define CLIENT_FIFO_PATH "/tmp/fifo_client_%d"

#define SEND_BUF_SIZE 1024
#define RECV_BUF_SIZE 1024
#define CLIENT_FIFO_SIZE 128

int 	server_write_fd, client_read_fd, client_write_fd;
char	client_fifo[CLIENT_FIFO_SIZE];
char    send_buf[SEND_BUF_SIZE];

static int  fifo_mode = S_IRUSR| S_IWUSR| S_IRGRP| S_IWGRP;

/*
 * create client fifo
 * success : 0 failed : -1
 */
int fifo_init(void)
{
	int 		ret;
	struct stat filestat;

	memset(client_fifo, 0, CLIENT_FIFO_SIZE);
	sprintf(client_fifo, CLIENT_FIFO_PATH, getpid());

	ret = stat(client_fifo, &filestat);
	if(ret == 0){
		if (unlink(client_fifo) < 0){
			perror("Cannot delete old MI fifo");
			return -1;
		}
	}else if(ret < 0 && errno != ENOENT){
		perror("MI FIFO stat failed");
		return -1;
	}

    if((mkfifo(client_fifo, fifo_mode) < 0)){
        perror("Create client fifo error");
      	return -1; 
    }

    if((chmod(client_fifo, fifo_mode) < 0)){
        perror("Chmod client fifo error");
		goto error;
    }

	return 0;

error:
   	remove(client_fifo);
	return -1;
		
}

/*
 * open server fifo for writing
 * success : fd failed : -1
 */
int open_server_fifo(char *pipe_name)
{
    int     flags;

    if(!pipe_name || *pipe_name == 0){
        printf("No server fifo to open\n");
        return -1;
    }

    server_write_fd = open(pipe_name, O_WRONLY|O_NONBLOCK);
    if(server_write_fd < 0){
        perror("Can't open server fifo error");
        return -1;
    }

    if((flags = fcntl(server_write_fd, F_GETFL, 0)) < 0){
        perror("Server fifo F_GETFL error");
        goto error;
    }

    flags&=~O_NONBLOCK;

    if(fcntl(server_write_fd, F_SETFL, flags) < 0){
        perror("Server fifo F_GETFL error");
        goto error;
    }

    return 0;

error:
    close(server_write_fd);
    return -1;
}

/*
 * open client fifo
 * success : fd failed : -1
 */
int open_client_fifo(char * pipe_name)
{
    int     flags;

    if(!pipe_name || *pipe_name == 0){
        printf("No client fifo to open.\n");
        return -1;
    }

    client_read_fd = open(pipe_name, O_RDONLY|O_NONBLOCK);
    if(client_read_fd < 0){
        printf("Can't open client fifo for reading");
        return -1;
    }

    client_write_fd = open(pipe_name, O_WRONLY|O_NONBLOCK);
    if(client_write_fd < 0){
        printf("Can't open client fifo for writing\n");
        return -1;
    }

    if((flags = fcntl(client_read_fd, F_GETFL, 0)) < 0){
        printf("Client fifo F_GETFL error.\n");
        goto error;
    }

    flags&=~O_NONBLOCK;

    if(fcntl(client_read_fd, F_SETFL, flags) < 0){
        printf("Client fifo F_SETFL error.\n");
        goto error;
    }

    return 0;

error:
    close(client_read_fd);
    close(client_write_fd);
    return -1;
}


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

    int     ret;
    char    recv_buf[RECV_BUF_SIZE];

    if(fifo_init()){
		return -1;
    }

    if(open_client_fifo(client_fifo)){
		goto error1;
    }

    if(open_server_fifo(SERVER_FIFO_PATH)){
		goto error2;
    }

	sprintf(send_buf, ":%s:hello, server.", client_fifo);
    ret = write(server_write_fd, send_buf, strlen(send_buf));
    if(ret < 0){
        perror("Write data to server fifo error");
		goto error3;
    }

	memset(recv_buf, 0, RECV_BUF_SIZE);
   	if((ret = read(client_read_fd, recv_buf, RECV_BUF_SIZE)) > 0){
		printf("Receive data form server : %s", recv_buf);
	}

   	close(client_read_fd);
  	close(server_write_fd);
   	remove(client_fifo);

	exit(EXIT_SUCCESS);

error3:
	close(server_write_fd);
error2:
	close(client_read_fd);
	close(client_write_fd);
error1:
   	remove(client_fifo);
	
	exit(EXIT_FAILURE);	
}

select版本

服务端

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

#define RECV_BUF_SIZE 1024
#define SEND_BUF_SIZE 1024
#define CONTENT_LEN 128
#define ARGUMENT_LEN 128

#define DATA_SEPARATOR ':'
#define SERVER_FIFO_PATH "/tmp/fifo_server"

int 	server_write_fd, server_read_fd, client_write_fd;
char    send_buf[SEND_BUF_SIZE];
char	content[CONTENT_LEN];
char	client_fifo_path[ARGUMENT_LEN];
char    recv_buf[RECV_BUF_SIZE];
char    send_buf[SEND_BUF_SIZE];

static int  fifo_mode = S_IRUSR| S_IWUSR| S_IRGRP| S_IWGRP;

/*
 * create server fifo
 * success : 0 failed : -1
 */
int fifo_init(void)
{
	int 		ret;
	struct stat filestat;


	ret = stat(SERVER_FIFO_PATH, &filestat);
	if(ret == 0){
		if (unlink(SERVER_FIFO_PATH) < 0){
			perror("Cannot delete old MI fifo");
			return -1;
		}
	}else if(ret < 0 && errno != ENOENT){
		perror("MI FIFO stat failed");
		return -1;
	}

    if((mkfifo(SERVER_FIFO_PATH, fifo_mode) < 0)){
        perror("Create client fifo error");
      	return -1; 
    }

    if((chmod(SERVER_FIFO_PATH, fifo_mode) < 0)){
        perror("Chmod client fifo error");
		goto error;
    }

	return 0;

error:
   	remove(SERVER_FIFO_PATH);
	return -1;
		
}

/*
 * open server fifo
 * success : fd failed : -1
 */
int open_client_fifo(char *pipe_name)
{
    int     flags;

    if(!pipe_name || *pipe_name == 0){
        printf("No server fifo to open\n");
        return -1;
    }

    client_write_fd = open(pipe_name, O_WRONLY|O_NONBLOCK);
    if(client_write_fd < 0){
        perror("Can't open server fifo error");
        return -1;
    }

    if((flags = fcntl(client_write_fd, F_GETFL, 0)) < 0){
        perror("Server fifo F_GETFL error");
        goto error;
    }

    flags&=~O_NONBLOCK;

    if(fcntl(client_write_fd, F_SETFL, flags) < 0){
        perror("Server fifo F_GETFL error");
        goto error;
    }

    return 0;

error:
    close(client_write_fd);
    return -1;
}

/*
 * open server  fifo for reading
 * success : fd failed : -1
 */
int open_server_fifo(char * pipe_name)
{
    //int     flags;

    if(!pipe_name || *pipe_name == 0){
        printf("No client fifo to open");
        return -1;
    }

    server_read_fd = open(pipe_name, O_RDONLY|O_NONBLOCK);
    if(server_read_fd < 0){
        printf("Can't open client fifo for reading");
        return -1;
    }

    return 0;
}

int data_parse(void)
{
	char	*p, *postion;
	
	p = recv_buf;


	if(*p != DATA_SEPARATOR){
		printf("command must begin with %c\n", DATA_SEPARATOR);
		return -1;
	}
	p++;

	postion = strchr(p, DATA_SEPARATOR);
	if(postion == NULL){
		printf("file separator missing in fifo command\n");
		return -1;
	}
	strncpy(client_fifo_path, p, postion - p);

	p = ++postion;
	strncpy(content, p, strlen(p));

	return 0;
}

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

    int     ret, maxfd;
	fd_set	set, read_set;
	struct	timeval timeout;

    if(fifo_init()){
		return -1;
    }

    if(open_server_fifo(SERVER_FIFO_PATH)){
		goto error;
    }

	FD_ZERO(&set);
	FD_SET(server_read_fd, &set); 
	maxfd = server_read_fd + 1;

   	while(1){
		read_set = set;
		timeout.tv_sec = 2;
		timeout.tv_usec = 0;

		memset(recv_buf, 0, RECV_BUF_SIZE);
		ret = select(maxfd, &read_set, NULL, NULL, &timeout);
		switch(ret){
			case 0:
				continue;
			case -1:
				perror("select");
				continue;
			default:
				if(FD_ISSET(server_read_fd, &read_set)){
					if((ret = read(server_read_fd,
						recv_buf, RECV_BUF_SIZE)) > 0){

						if(data_parse()){
							continue;
						}
						printf("Receive data from <%s> : %s\n",
								client_fifo_path, content);

    					if(open_client_fifo(client_fifo_path)){
							continue;
    					}

						sprintf(send_buf, "hello, %s\n", client_fifo_path);
						ret = write(client_write_fd, 
									send_buf, strlen(send_buf));
						if(ret < 0){
							perror("Write data to client fifo error");
							continue;
						}
					}
				}
		}
	}

	remove(SERVER_FIFO_PATH);
	exit(EXIT_SUCCESS);

error:
	remove(SERVER_FIFO_PATH);
	exit(EXIT_FAILURE);
}

客户端

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

#define RECV_BUF_SIZE 1024
#define SEND_BUF_SIZE 1024
#define CONTENT_LEN 128
#define ARGUMENT_LEN 128

#define DATA_SEPARATOR ':'
#define SERVER_FIFO_PATH "/tmp/fifo_server"

int 	server_write_fd, server_read_fd, client_write_fd;
char    send_buf[SEND_BUF_SIZE];
char	content[CONTENT_LEN];
char	client_fifo_path[ARGUMENT_LEN];
char    recv_buf[RECV_BUF_SIZE];
char    send_buf[SEND_BUF_SIZE];

static int  fifo_mode = S_IRUSR| S_IWUSR| S_IRGRP| S_IWGRP;

/*
 * create server fifo
 * success : 0 failed : -1
 */
int fifo_init(void)
{
	int 		ret;
	struct stat filestat;


	ret = stat(SERVER_FIFO_PATH, &filestat);
	if(ret == 0){
		if (unlink(SERVER_FIFO_PATH) < 0){
			perror("Cannot delete old MI fifo");
			return -1;
		}
	}else if(ret < 0 && errno != ENOENT){
		perror("MI FIFO stat failed");
		return -1;
	}

    if((mkfifo(SERVER_FIFO_PATH, fifo_mode) < 0)){
        perror("Create client fifo error");
      	return -1; 
    }

    if((chmod(SERVER_FIFO_PATH, fifo_mode) < 0)){
        perror("Chmod client fifo error");
		goto error;
    }

	return 0;

error:
   	remove(SERVER_FIFO_PATH);
	return -1;
		
}

/*
 * open server fifo
 * success : fd failed : -1
 */
int open_client_fifo(char *pipe_name)
{
    int     flags;

    if(!pipe_name || *pipe_name == 0){
        printf("No server fifo to open\n");
        return -1;
    }

    client_write_fd = open(pipe_name, O_WRONLY|O_NONBLOCK);
    if(client_write_fd < 0){
        perror("Can't open server fifo error");
        return -1;
    }

    if((flags = fcntl(client_write_fd, F_GETFL, 0)) < 0){
        perror("Server fifo F_GETFL error");
        goto error;
    }

    flags&=~O_NONBLOCK;

    if(fcntl(client_write_fd, F_SETFL, flags) < 0){
        perror("Server fifo F_GETFL error");
        goto error;
    }

    return 0;

error:
    close(client_write_fd);
    return -1;
}

/*
 * open server  fifo for reading
 * success : fd failed : -1
 */
int open_server_fifo(char * pipe_name)
{
    //int     flags;

    if(!pipe_name || *pipe_name == 0){
        printf("No client fifo to open");
        return -1;
    }

    server_read_fd = open(pipe_name, O_RDONLY|O_NONBLOCK);
    if(server_read_fd < 0){
        printf("Can't open client fifo for reading");
        return -1;
    }

    return 0;
}

int data_parse(void)
{
	char	*p, *postion;
	
	p = recv_buf;


	if(*p != DATA_SEPARATOR){
		printf("command must begin with %c\n", DATA_SEPARATOR);
		return -1;
	}
	p++;

	postion = strchr(p, DATA_SEPARATOR);
	if(postion == NULL){
		printf("file separator missing in fifo command\n");
		return -1;
	}
	strncpy(client_fifo_path, p, postion - p);

	p = ++postion;
	strncpy(content, p, strlen(p));

	return 0;
}

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

    int     ret, maxfd;
	fd_set	set, read_set;
	struct	timeval timeout;

    if(fifo_init()){
		return -1;
    }

    if(open_server_fifo(SERVER_FIFO_PATH)){
		goto error;
    }

	FD_ZERO(&set);
	FD_SET(server_read_fd, &set); 
	maxfd = server_read_fd + 1;

   	while(1){
		read_set = set;
		timeout.tv_sec = 2;
		timeout.tv_usec = 0;

		memset(recv_buf, 0, RECV_BUF_SIZE);
		ret = select(maxfd, &read_set, NULL, NULL, &timeout);
		switch(ret){
			case 0:
				continue;
			case -1:
				perror("select");
				continue;
			default:
				if(FD_ISSET(server_read_fd, &read_set)){
					if((ret = read(server_read_fd,
						recv_buf, RECV_BUF_SIZE)) > 0){

						if(data_parse()){
							continue;
						}
						printf("Receive data from <%s> : %s\n",
								client_fifo_path, content);

    					if(open_client_fifo(client_fifo_path)){
							continue;
    					}

						sprintf(send_buf, "hello, %s\n", client_fifo_path);
						ret = write(client_write_fd, 
									send_buf, strlen(send_buf));
						if(ret < 0){
							perror("Write data to client fifo error");
							continue;
						}
					}
				}
		}
	}

	remove(SERVER_FIFO_PATH);
	exit(EXIT_SUCCESS);

error:
	remove(SERVER_FIFO_PATH);
	exit(EXIT_FAILURE);
}






tj807126663
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程通信（IPC）方式简介
09-15
linux下进程间通信的几种主要方式：管道（pipe）和有名管道（FIFO）、信号（signal）、消息队列、共享内存（shared memory）、信号量（semaphore）、套接字（socket)，本文对这些做简单介绍
Linux环境编程之IPC进程间通信(三)：FIFO
李冰-冰斌
06-04 2177
管道是没有名字的，因此它只能在有qinyuan
IPC -- 管道和FIFO
nia305的博客
06-28 145
1.第一种IPC：管道【未命名管道】    过程：    主要调用int pipe(int fd[2])函数来创建一个管道，其中fd[0]代表读端，fd[1]代表写端，我们可以调用pipe之后，fork子进程，然后按照需求来关闭相应的读端和写端，这样父子进程就可以进行通讯。    缺点：    fd存在内存里面，程序退出就不见了，并且管道只能用在有关系的进程之间，任意两个进程不能通过管道来相互通讯...
Linux IPC之管道和FIFO
delphiwcdj的专栏
08-31 3845
导言：管道是UNIX系统上最古老的IPC方法，管道提供了一种优雅的解决方案：给定两个运行不同程序的进程，在shell中如何让一个进程的输出作为另一个进程的输入？管道可以用来在相关（一个共同的祖先进程创建管道）进程之间传递数据。FIFO是管道概念的一个变体，它们之间的一个重要差别在于FIFO可以用于任意进程间的通信。 概述每个shell用户都对在命令中使用管道比较熟悉，例如，统计一个目录中文件的数目：
进程间通信（IPC）——FIFO（命名管道）
qq_52621551的博客
09-16 366
FIFO，也称为命名管道，它是一种文件类型。 特点： 1.FIFO可以在无关的进程之间交换数据，与无名管道不同。 2.FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。 原型： SYNOPSIS #include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *pathname, mode_t mode)...
系统api－管道和FIFO
x13262608581的博客
11-12 164
管道，FIFO
Linux下进程间通信FIFO演示程序
05-21
一个简单程序，演示了Linux下的FIFO IPC机制 http://blog.csdn.net/ZhengZhiRen/archive/2010/05/21/5613843.aspx
Linux进程通信--FIFO(写)
01-05
Linux进程间通信之FIFO,适用于任意进程间. 此C文件为FIFO的写端
6_pipe_fifo
11-21
linux 进程间通信 pipe和fifo实现 。（此为博客http://blog.csdn.net/shallnet 文章对应源码下载）
Linux进程通信--FIFO(读)
01-05
Linux进程间通信之FIFO,适用于任意两个进程间.此C文件件为读端.
FIFO配合管道PIPE，实现FIFO传递数据，PIPE触发epoll，异步IO效果
03-28
FIFO配合管道PIPE，实现FIFO传递数据，PIPE触发epoll，异步IO效果
FIFO简单使用
hzq_blog
07-26 3039
先启动服务端，./server &amp;amp;,然后启动客户端，输入一个文件名 服务端：server.c #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;unistd.h&amp;gt; #define _GNU_SOURCE /* See feature_test_macros(7) */ #include &amp;lt;fcntl.h&amp;gt;
Linux下利用命名管道实现简单的聊天室
TOmyLord的博客
09-21 1119
1、服务器端 ①先建立一个Sever_FIFO文件 用于接收来自不同客户端的数据，所有客户端的数据都会发送至这个文件，经过处理后再转存到别的文件之后才会发送到另一个客户端上。 ②利用结构体传输过来客户端的pid，并将pid存在pid【】数组中，pid的值是用来区分将信息回传的依据。 ③通过简单的pid区分传来的结构体中的数据应该回传的文件，并将数据写入该文件。不停的重复此步骤。 2
FIFO服务器程序以及客户端程序
u011230664的专栏
02-21 321
服务器程序： #include "client.h" #include <ctype.h> #include <fcntl.h> int main() { int server_fifo_fd, client_fifo_fd,server_fifo_fd_write; struct data_to_pass_st my_data; int read_...
进程间通信(IPC):FIFO
不积跬步无以至千里
05-11 603
FIFO又称命名管道，可以在无亲缘关系即不相关的进程间交换数据。 创建FIFO： #include #include int mkfifo(const char* pathname,mode_t mode); 创建FIFO后，可以用一般的文件io函数来操作，open，close，read,write,unlink等。 非阻塞标志O_NONBLOCK的影响： 未指定O_NONB
Linux进程间通信(上)之管道、消息队列实践
Bruce.yang的嵌入式之旅
09-01 760
1、进程间通信简述进程间通信的几种方式：无名管道、有名管道、消息队列、共享内存、信号、信号量、套接字（socket）。进程间通信是不同进程直接进行的一些接触，这种接触有简单，有复杂。机制...
linux程序设计——使用FIFO的客户/服务器的应用程序（第十三章）
yiranant的专栏
07-15 1418
13.6.2    使用FIFO的客户/服务器应用程序 作为学习FIFO的最后一部分内容，现在考虑怎样通过命名管道来编写一个非常简答的客户/服务器应用程序。用一个服务器进程来接受请求，对它们进行处理，最后把结果数据返回给发送请求的一方：客户。 如果想要允许多个客户进行都可以向服务器发送数据，假设被处理的数据可以被拆分为一个个数据块，每个的长度都小于PIPE_BUF字节。 因为服务器每次只能处
FIFO的两种输出：时序输出与组合逻辑输出
chenchen410的专栏
07-21 2528
对于FIFO的输出有两种：1、输出为时序clk，这样
FIFO实现IPC系统的缺点
最新发布
04-22
FIFO实现IPC系统的缺点包括： 1. 有一定的延迟：由于FIFO必须按顺序进行读写操作，因此在写入和读取数据之间可能会存在一定的延迟。 2. 数据可靠性问题：FIFO是一种无连接的通信方式，因此在传输过程中无法保证...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值