精华内容
下载资源
问答
  • 文章目录1,有名管道的特点2,有名管道创建mkfifo()3,有名管道读写---示例 1,有名管道的特点 对应管道文件,可用于任意进程之间进行通信:有名管道创建好之后,在系统中有实际的文件和有名管道对应,...

    1,有名管道的特点

    1. 对应管道文件,可用于任意进程之间进行通信:有名管道创建好之后,在系统中有实际的文件和有名管道对应,任意两个进程可以通过路径和文件名指定同一个有名管道进行通信
    2. 打开管道时可指定读写方式:有名管道用open()打开的时候可以指定不同的读写方式,从而可以确定读端和写端
    3. 通过文件IO操作,内容存放在内存中:通过文件IO read()和write()进行操作。虽然有名管道有一个实际的文件被创建,在文件系统中可见,但是往管道中写入的所有内容实际上依然是存放在内存中的(跟无名管道一样),当所有的读端和写端都关闭的时候,管道存放在内存中的内容都会被释放
    4. 有名管道打开的时候有可能会阻塞。当只有读端或只有写端的时候,open()会阻塞,只有当读端和写端同时存在的时候,open()才会返回,程序才会继续执行。

    2,有名管道的创建mkfifo()

    #include <unistd.h>
    #include <fcntl.h>
    int mkfifo(const char *path, mode_t mode);

    1. 成功时返回0,失败时返回EOF(如果创建的管道已经存在,创建就会失败)
    2. path 创建的管道文件路径
    3. mode 管道文件的权限,如0666(管道文件的权限主要是读写权限)

    3,有名管道读写—示例

    进程A:循环从键盘输入并写入有名管道myfifo,输入quit时退出
    进程B:循环统计进程A每次写入myfifo的字符串的长度

    /*  create_fifo.c  */
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main(int argc, const char *argv[])
    {
    	if(mkfifo("myfifo",0666) < 0)
    	{
    		perror("mkfifo");
    		exit(-1);
    	}
    
    	return 0;
    }
    
    /*  write_fifo.c  */
    #include <stdio.h>
    #include <stdlib.h>
    #include <fcntl.h>
    #include <string.h>
    
    #define N 32
    int main(int argc, const char *argv[])
    {
    	char buf[N];
    	int pfd;
    
    	if((pfd = open("myfifo",O_WRONLY)) < 0)
    	{
    		perror("open");
    		exit(-1);
    	}
    	printf("write myfifo\n");//进程打开管道后显示这一句
    	while(1)
    	{
    		printf("Please input a string (quite exit!\n");
    		fgets(buf,N,stdin);
    		if(strcmp(buf,"quite\n") == 0)break;
    		write(pfd,buf,N);
    	}
    
    	close(pfd);
    
    	return 0;
    }
    
    /*  read_fifo.c  */
    #include <stdio.h>
    #include <fcntl.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define N 32
    
    int main(int argc, const char *argv[])
    {
    	char buf[N];
    	int pfd;
    
    	if((pfd = open("myfifo",O_RDONLY)) < 0)
    	{
    		perror("open");
    		exit(-1);
    	}
    	printf("read myfifo\n");//进程打开管道后显示这一句	
    	while(read(pfd,buf,N) > 0)//写端存在,管道中没有数据的时候,读管道阻塞;写端不存在,管道中没有数据的时候,read()返回0
    	{
    		printf("the length of string is %d\n",strlen(buf));
    	}
    	close(pfd);
    
    	return 0;
    }
    

    1,创建好三个c文件,并编译

    linux@linux:~/test/stdio/fifo_sample$ ls
    fifo_create.c  fifo_read.c  fifo_write.c
    linux@linux:~/test/stdio/fifo_sample$ gcc fifo_create.c -o fifo_create.out
    linux@linux:~/test/stdio/fifo_sample$ gcc fifo_write.c -o fifo_write.out
    linux@linux:~/test/stdio/fifo_sample$ gcc fifo_read.c -o fifo_read.out
    linux@linux:~/test/stdio/fifo_sample$ ls
    fifo_create.c  fifo_create.out  fifo_read.c  fifo_read.out  fifo_write.c fifo_write.out
    

    2,运行fifo_create.out,可以看到多了管道文件

    linux@linux:~/test/stdio/fifo_sample$ ./fifo_create.out 
    linux@linux:~/test/stdio/fifo_sample$ ll
    total 44
    drwxrwxr-x 2 linux linux 4096 11月 12 11:13 ./
    drwxrwxr-x 6 linux linux 4096 11月 12 01:01 ../
    -rw-rw-r-- 1 linux linux  185 11月 12 10:13 fifo_create.c
    -rwxrwxr-x 1 linux linux 7418 11月 12 11:04 fifo_create.out*
    -rw-rw-r-- 1 linux linux  379 11月 12 11:03 fifo_read.c
    -rwxrwxr-x 1 linux linux 7647 11月 12 11:05 fifo_read.out*
    -rw-rw-r-- 1 linux linux  438 11月 12 11:03 fifo_write.c
    -rwxrwxr-x 1 linux linux 7681 11月 12 11:04 fifo_write.out*
    prw-rw-r-- 1 linux linux    0 11月 12 11:13 myfifo|
    
    • 可以看到管道文件大小是0,实际上管道文件大小永远是0,因为管道中的内容是保存在内存里的,而不是磁盘上

    3,运行fifo_read.out或fifo_write.out,可以看到程序处于阻塞状态。以先运行fifo_read.out为例(先运行写管道也一样)

    linux@linux:~/test/stdio/fifo_sample$ ./fifo_read.out 
    
    
    linux@linux:~/test/stdio/fifo_sample$ ps -aux |grep fifo
    linux     3089  0.0  0.5  15196  6072 pts/10   S+   10:49   0:01 vi fifo_read.c
    linux     3306  0.0  0.0   2024   280 pts/12   S+   11:15   0:00 ./fifo_read.out
    linux     3314  0.0  0.0   6108   852 pts/0    S+   11:18   0:00 grep --color=auto fifo
    
    1. 当进程打开一个有名管道的时候,如果当前只有读端或只有写端,open()会阻塞
      open()的下一条指令
      printf(“read myfifo\n”);//进程打开管道后显示这一句
      没有执行
    2. 只有当读端和写端都存在是,两个进程中的open()才能正常执行

    4,在另一个终端运行

    读进程 写进程
    linux@linux:~/test/stdio/fifo_sample$ ./fifo_read.out
    write myfifo
    linux@linux:~/test/stdio/fifo_sample$ ./fifo_write.out
    write myfifo
    Please input a string (quite exit!
    the length of string is 4
    qwe
    Please input a string (quite exit!
    the length of string is 2
    w
    Please input a string (quite exit!
    linux@linux:~/test/stdio/fifo_sample$
    quite
    linux@linux:~/test/stdio/fifo_sample$
    1. 运行fifo_write.out后,管道有了写端,读进程和写进程的open()才能正常运行,可以看到open()的下一条指令
      printf(“read myfifo\n”);//进程打开管道后显示这一句
      printf(“write myfifo\n”);//进程打开管道后显示这一句
      正常执行了
    2. 当写端输入quite时,写端不存在了,当写端不存在了,并且管道中没有数据数据,读管道会立刻返回0,返回0,就会退出循环,程序结束
    展开全文
  • pipe创建管道只能在具有共同祖先的进程间通信,而mkfifo能在不相关的进程间交换数据。通俗举例来说,一个在一个c文件中通信,一个可在多个c文件中通信。 命名管道打开的规则: 为读打开FIFO: O_NONBLOCK disable...
    pipe创建的管道只能在具有共同祖先的进程间通信,而mkfifo能在不相关的进程间交换数据。通俗举例来说,一个在一个c文件中通信,一个可在多个c文件中通信。
    命名管道打开的规则:
    为读打开FIFO:
    O_NONBLOCK disable:阻塞直到有相应进程为写而打开FIFO
    O_NONBLOCK enable:立刻返回成功
    为写打开FIFO:
    O_NONBLOCK disable:阻塞直到有相应进程为读而打开FIFO
    O_NONBLOCK enable:立刻返回失败,错误码为ENXIO
    打开文件描述符默认为阻塞。


    管道创建与写管道程序:
    #include<stdio.h>
    #include<sys/stat.h>
    #include<unistd.h>
    #include<errno.h>
    #include<fcntl.h>
    #define SIZE 20

    int main( int argc, char **argv )
    {
        int fd;

        if( (mkfifo(argv[1], 0666)==-1) && (errno!=EEXIST) )//加后一半可令创建管道后的再次读取不输出错误提示!
        {
            perror( "create fifo error!" );
            exit( -1 );
        }
        if( (fd=open(argv[1], O_WRONLY)) == -1 )
        {
            perror( "open file error!" );
            exit( -1 );
        }
        write( fd, argv[2], SIZE );
        close( fd );
        puts( "write success!" );

        exit( 1 );
    }


    管道接收程序:
    #include<stdio.h>
    #include<sys/stat.h>
    #include<unistd.h>
    #include<errno.h>
    #include<fcntl.h>
    #include<stdlib.h>
    #define SIZE 20

    int main( int argc, char **argv )
    {
        int fd;
        char buffer[SIZE];

        if( (fd=open(argv[1], O_RDONLY | O_NONBLOCK)) == -1 )
        {
            perror( "open file error!" );
            exit( -1 );
        }
        while( 1 )
        {
            memset( buffer, 0, SIZE );
            if( read(fd, buffer, SIZE) == -1 )
            {
                perror( "please input something!" );
            }
            else
            {
                printf( "receieve %s!", buffer );
            }
            sleep( 1 );
        }
    }

    展开全文
  • 有名管道创建

    2013-05-13 08:58:55
    创建有名管道有两种方式: 一是在 shell 下交互地建立一个有名管道,二是在程序中使用系统函数建立有名管道。shell 方式下可使用 mknod 或 mkfifo 命令,下面命令使用 mknod 创建了一个有名管道: mknod...

    有名管道的创建与读写

    创建有名管道有两种方式:
    一是在 shell 下交互地建立一个有名管道,二是在程序中使用系统函数建立有名管道。shell 方式下可使用 mknod 或 mkfifo 命令,下面命令使用 mknod 创建了一个有名管道:
    mknod namepipe
    创建有名管道的系统函数有两个:mknod() 和 mkfifo() 。两个函数均定义在头文件 sys/stat.h 中,函数原型如下:
    引用
    #include <sys/types.h>
    #include <sys/stat.h>

    int mknod(const char *pathname, mode_t mode, dev_t dev);
      int mkfifo(const char *pathname, mode_t mode);

    函数 mknod() 参数中path 为创建的有名管道的全路径名;mod 为创建的有名管道的模式,指明其存取权限;dev 为设备值,该值取决于文件创建的种类,它只在创建设备文件时才会用到。这两个函数成功返回 0,失败则返回 -1。
    通过查看相关头文件,可以看到 mode_t 是 unsigned int  类型
    使用 mknod() 创建一个有名管道
    引用
    umask(0);
    if (mknod ("/tmp/fifo", S_IFIFO | 0666, 0== -1{
          perror("mknod error!");
          exit(1);
    }


    使用 mkfifo() 创建有名管道,mkfifo() 前两个参数的含义和 mknod() 相同
    引用
    umask(0);
    if (mkfifo ("/tmp/fifo", S_IFIFO | 0666, 0== -1{
          perror("mkfifo error!");
          exit(1);
    }


    “S_IFIFO | 0666" 指明创建一个有名管道且存取权限为 0666 ,即创建者、与创建者同组的用户、其他用户对该有名管道的访问权限都是可读可写。

    有名管道创建后就可以使用了,有名管道的和管道的使用方法基本相同。只是使用有名管道时,必须先调用 open() 将其打开,因为有名管道是一个存在硬盘上的文件,而管道是存在内存中的特殊文件。

    需要注意的是,调用 open() 打开有名管道的进程可能会被阻塞。但如果同时以读写方式 ( O_RDWR ) 打开,则一定不会导致阻塞;如果以只读方式 ( O_RDONLY ) 打开,则调用 open() 函数的进程将会被阻塞直到有写方打开管道;同样以写方式 ( O_WRONLY ) 打开也会阻塞直到有读方打开管道。
    展开全文
  • 在平时的练习中, 一般使用soursight进行代码的书写 ...但是在创建有名管道的时候却遇到了问题 总是提示操作不被允许 最后的解决方案是 不能在共享文件夹下面进行操作 换到Linux下的家目录就没问题了 ...

    在平时的练习中,
    一般使用soursight进行代码的书写
    于是就在Windows文件夹下面创建了一个共享文件夹

    但是在创建有名管道的时候却遇到了问题
    总是提示操作不被允许

    最后的解决方案是
    不能在共享文件夹下面进行操作
    换到Linux下的家目录就没问题了

    展开全文
  • 如题。 代码为: pipe_ = CreateNamedPipe(L"\\\\.\\pipe\\thistest\\test"), FILE_FLAG_FIRST_PIPE_INSTANCE | PIPE_ACCESS_DUPLEX| FILE_FLAG_OVERLAPPED, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE ...
  • 有名管道创建与读写

    千次阅读 2011-09-27 10:47:23
    创建有名管道有两种方式: 一是在 shell 下交互地建立一个有名管道,二是在程序中使用系统函数建立有名管道。shell 方式下可使用 mknod 或 mkfifo 命令,下面命令使用 mknod 创建了一个有名管道: mknod...
  • 有名管道

    2020-11-26 12:47:19
    方法1:用shell命令mkfifo创建有名管道 mkfifo 文件名 方法2:使用函数mkfifo #include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *pathname, mode_t mode); 功能: 创建一个...
  • int mkfifo(const char *pathname, mode_t mode);int mknod(const char *pathname, mode_t mode, ...在有名管道(named pipe或FIFO)提出来之后,该限制得到了克服。FIFO不同于管道之处在于它提供一个路径与之关联,以...
  • 有名管道为什么叫“有名管道有名管道特点能够用于非亲缘进程之间的通信进入阻塞读端口被关闭的处理有名管道的使用步骤有名管道API...也就是说当我们调用相应的API创建好“有名管道”后,会在相应的路径下面看到一...
  • 1、创建管道的时候,使用的函数:int mkfifo(const char *pathname, mode_t mode); 2、删除管道的时候,使用的函数:int unlink(const char *path); 3、这两个函数的返回值,如果是-1,说明失败。 步骤: 1、...
  • #include #include #include #include #include #if 1 //创建两个FIFO实现不同进程间的全双工通信 --实现自由通信 //有名管道创建及读写extern int errno;//..............ser.c --服务端 int main() {
  • linux有名管道

    2019-08-03 19:42:13
    正由于这无名管道的缺点,对无名管道进行改进:有名管道。 所谓的有名,即文件系统中存在这个一样文件节点,每一个文件节点都有一个inode号 而且这是一个特殊的文件类型:p管道类型。 创建这个文件节点,不可以...
  • 头文件 #include <sys/types.h> #include <sys/stat.h> 函数声明 int mkfifo(const char *pathname, mode_t mode);...成功返回0,失败返回-1并设置errno ... ~umask)的有名管道文件 目的 解决没有血缘...
  • 52-有名管道

    千次阅读 2017-01-04 11:30:03
    有名管道打破了无名管道的限制,进化出了一个实实在在的 FIFO 类型的文件。这意味着即使没有亲缘关系的进程也可以互相通信了。所以,只要不同的进程打开 FIFO 文件,往此文件读写数据,就可以达到通信的目的。不过 ...
  • 1. 概念 有名管道又称为FIFO文件,因为我们对有名管道的操作可以采用操作文件的方法,如使用open,read,write等。...2. 创建有名管道(fifo文件) 2.1 函数原型 #include <sys/stat.h> int mk
  • 有名管道管道编程

    2016-05-06 09:44:56
    编写两个程序,一个程序负责创建有名管道,并往有名管道中写数据,另一个程序负责读取有名管道数据,并删除有名管道。 对应写进程: 运行程序 可以看到,程序被阻塞掉了,因为程序在等待...
  • 有名管道通信

    2017-10-18 23:18:50
    信号通信、管道通信(有名管道通信和无名管道通信)、信号量通信、消息队列通信、共享内存(或共享储存)、套接字通信。 如果进程A输入“hello world”,进程B读取并输入,有什么方式可以做到呢?之前学过...
  • 接上一篇的无名管道,今天总结一下进程间通信...于是,即使与FIFO的创建进程不存在亲缘关系的进程,只要有可以访问该路径,FIFO就可以为它们提供通信,所以有名管道不仅可以用于有亲缘关系间的通信,也可以用于无亲缘进
  • Liunx_4.4_有名管道

    2015-06-22 16:54:44
    (1) 有名管道: ...5.2创建有名管道 5.2.1 函数名 mkfifo 5.2.2 函数原形 int mkfifo(const char*pathname,mode_t mode) 5.2.3 函数功能 创建fifo文件(有名管道) 5.2.4 所属头文件 #include #include 5.2
  • 有名管道通讯编程

    2016-06-04 08:10:00
    创建2个进程,在A进程中创建一个...用法:通过mkfifo创建有名管道,之后就可以想操作普通文件通过open()、close()、write()、以及read()对它进行相应操作。 1、创建一个有名管道--mkfifo 头文件:#include<sy...
  • FIFO 有名管道

    2013-05-06 08:54:56
    有名管道  在创建管道成功之后,就可以使用open()、read()和write()这些函数了。与普通文件的开发设置一样,对于为读而打开的管道可在open()中设置O_RDONLY,对于为写而打开的管道可在open()中设置O_WRONLY,在这里与...
  • 1 有名管道fifo原理 1)有名管道fifo在多进程间通信是不需要有血缘关系的,和pipe无名管道不一样。但是原理都是在内核空间中创建相应的内核缓冲区buf。 2)FIFO是Linux基础文件类型中的一种。但,FIFO文件在磁盘上...
  • 5 有名管道

    2017-01-21 13:59:12
    1. mkfifo 函数形式:int mkfifo(const char * filename, mode_t mode); 功能:创建管道文件 参数:管道文件名;权限,文件权限仍然和umask有关 ...只有在调用open代开有名管道时,才会在内核中创建管道。
  • 匿名管道和有名管道

    千次阅读 2018-07-08 17:27:20
    1. 管道的概念本质: 内核缓冲区  伪文件 - 不占用磁盘空间特点: 两部分: 读端,写端,对应两个文件描述符 数据写端流入, 读端流出 操作管道的进程被销毁之后,管道自动被释放了 管道读写两端默认是阻塞的 2....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,714
精华内容 1,885
关键字:

创建有名管道失败