zoukankan      html  css  js  c++  java
  • linux 有名管道(FIFO)

    http://blog.csdn.net/firefoxbug/article/details/8137762

    linux 有名管道(FIFO)

    管道的缓冲区是有限的(管道制存在于内存中,在管道创建时,为缓冲区分配一个页面大小)
    管道所传送的是无格式字节流,这就要求管道的读出方和写入方必须事先约定好数据的格式,比如多少字节算作一个消息(或命令、或记录)等等

    多个写进程,一个读进程。可以参考我之前的博客http://blog.csdn.net/firefoxbug/article/details/7358715

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

    一旦设置了阻塞标志,调用mkfifo建立好之后,那么管道的两端读写必须分别打开,有任何一方未打开,则在调用open的时候就阻塞。

    约定:如果一个进程为了从FIFO中读取数据而阻塞打开FIFO,那么称该进程内的读操作为设置了阻塞标志的读操作。(意思就是我现在要打开一个有名管道来读数据!)

    可以理解为管道的两端都建立好了,但是写端还没开始写数据!)

        则对于设置了阻塞标志的读操作来说,将一直阻塞(

    就是block住了,等待数据。它并不消耗CPU资源,这种进程的同步方式对CPU而言是非常有效率的。)

    • 对于没有设置阻塞标志读操作来说则返回-1,当前errno值为EAGAIN,提醒以后再试。

    造成阻塞的原因有两种

        FIFO内有数据,但有其它进程在读这些数据(

    对于各个读进程而言,这根有名管道是临界资源,大家得互相谦让,不能一起用。)

    • FIFO内没有数据。解阻塞的原因则是FIFO中有新的数据写入,不论信写入数据量的大小,也不论读操作请求多少数据量。

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

    约定:如果一个进程为了向FIFO中写入数据而阻塞打开FIFO,那么称该进程内的写操作为设置了阻塞标志的写操作。(意思就是我现在要打开一个有名管道来写数据!)

     

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

     

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

    设置了阻塞标志

     

    if (buf_to_write <=  PIPE_BUF) 		//写入的数据量不大于PIPE_BUF时
    then
    	if ( buf_to_write > system_buf_left )	//保证写入的原子性,要么一次性把buf_to_write全都写完,要么一个字节都不写!
    	then
    		block ;
    		until ( buf_to_write <= system_buf_left );
    		goto write ;
    	else
    		write ;
    	fi
    else
    	write ; //不管怎样,就是不断写,知道把缓冲区写满了才阻塞
    fi
    

    管道写端 pipe_read.c

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    //pipe_read.c

    #include <stdio.h>  
    #include <stdlib.h>  
    #include <string.h>  
    #include <fcntl.h>  
    #include <limits.h>  
    #include <sys/types.h>  
    #include <sys/stat.h>  
      
    #define FIFO_NAME "/tmp/my_fifo"  
    #define BUFFER_SIZE PIPE_BUF  
      
    int main()  
    {  
        int pipe_fd;  
        int res;  
      
        int open_mode = O_RDONLY;  
        char buffer[BUFFER_SIZE 1];  
        int bytes 0;  
      
        memset(buffer''sizeof(buffer));  
      
        printf("Process %d opeining FIFO O_RDONLY ", getpid());  
        pipe_fd = open(FIFO_NAME, open_mode);  
        printf("Process %d result %d ", getpid(), pipe_fd);  
      
        if (pipe_fd != -1)  
        {  
            do{  
                res = read(pipe_fd, buffer, BUFFER_SIZE);  
                bytes += res;  
            printf("%d ",bytes);
            }while(res 0);  
            close(pipe_fd);  
        }  
        else  
        {  
            exit(EXIT_FAILURE);  
        }  
      
        printf("Process %d finished, %d bytes read ", getpid(), bytes);  
        exit(EXIT_SUCCESS);  
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61

    管道读端 pipe_write.c

    //pipe_write.c

    #include <stdio.h>  
    #include <stdlib.h>  
    #include <string.h>  
    #include <fcntl.h>  
    #include <limits.h>  
    #include <sys/types.h>  
    #include <sys/stat.h>  
      
    #define FIFO_NAME "/tmp/my_fifo"  
    #define BUFFER_SIZE PIPE_BUF  
    #define TEN_MEG (1024 * 100)  
      
    int main()  
    {  
        int pipe_fd;  
        int res;  
        int open_mode = O_WRONLY;  
      
        int bytes 0;  
        char buffer[BUFFER_SIZE 1];  
      
        if (access(FIFO_NAME, F_OK== -1)  
        {  
            res = mkfifo(FIFO_NAME0777);  
            if (res != 0)  
            {  
                fprintf(stderr"Could not create fifo %s ", FIFO_NAME);  
                exit(EXIT_FAILURE);  
            }  
        }  
      
        printf("Process %d opening FIFO O_WRONLY ", getpid());  
        pipe_fd = open(FIFO_NAME, open_mode);  
        printf("Process %d result %d ", getpid(), pipe_fd);  
      
       //sleep(20);
        if (pipe_fd != -1)  
        {  
            while (bytes < TEN_MEG)  
            {  
                res = write(pipe_fd, buffer, BUFFER_SIZE);  
                if (res == -1)  
                {  
                    fprintf(stderr"Write error on pipe ");  
                    exit(EXIT_FAILURE);  
                }  
                bytes += res;  
            printf("%d ",bytes);
            }  
            close(pipe_fd);  
        }  
        else  
        {  
            exit(EXIT_FAILURE);  
        }  
      
        printf("Process %d finish ", getpid());  
        exit(EXIT_SUCCESS);  
    }
     
     
  • 相关阅读:
    移动Web开发规范概述
    hibernate 多对多
    hibernate 1 对1
    hibernate 双向1对多
    Hibernate 单项多对1
    Hibernate Session 4种对象状态
    Hibernate Session缓存
    Hibernaate 详解
    Hibernate学习 (一)
    Struts拦截器Interceptor
  • 原文地址:https://www.cnblogs.com/LiuYanYGZ/p/5900490.html
Copyright © 2011-2022 走看看