Named Pipes (FIFO) in Linux-Systemen

Linux-System ist ein Betriebssystem, das die gleichzeitige Ausführung mehrerer Aufgaben unterstützt. Es kann mehrere Prozesse gleichzeitig ausführen und dadurch die Systemauslastung und -effizienz verbessern. Wenn jedoch Datenaustausch und Zusammenarbeit zwischen diesen Prozessen erforderlich sind, müssen einige IPC-Methoden (Inter-Process Communication) verwendet werden, z. B. Signale, Nachrichtenwarteschlangen, gemeinsam genutzter Speicher, Semaphore usw. Unter diesen ist die berühmte Pipe (FIFO) eine relativ einfache und leistungsstarke IPC-Methode. Sie ermöglicht es zwei oder mehr Prozessen, Daten über eine Datei zu übertragen, ohne sich um den Inhalt und das Format der Datei zu kümmern. In diesem Artikel wird die Methode der benannten Pipes (FIFO) in Linux-Systemen vorgestellt, einschließlich des Erstellens, Öffnens, Lesens, Schreibens, Schließens und Löschens berühmter Pipes.

Eine wesentliche Einschränkung bei der Anwendung unbenannter Pipes besteht darin, dass sie keinen Namen haben und daher nur für die prozessübergreifende Kommunikation mit Affinität verwendet werden können. Diese Einschränkung wurde nach der Einführung benannter Pipes (benannte Pipes oder FIFOs) überwunden. FIFO unterscheidet sich von einer Pipe dadurch, dass es einen damit verbundenen Pfadnamen bereitstellt, der im Dateisystem in Form einer FIFO-Datei vorhanden ist. Selbst wenn keine Affinität zu dem Prozess besteht, der den FIFO erstellt, können sie auf diese Weise über den FIFO miteinander kommunizieren (zwischen dem Prozess, der auf den Pfad zugreifen kann, und dem Prozess, der ihn erstellt hat), solange auf den Pfad zugegriffen werden kann Daher besteht keine Korrelation über den FIFO. Prozesse können auch Daten austauschen. Es ist erwähnenswert, dass FIFO strikt dem First-In-First-Out folgt (First-In-First-Out). Beim Lesen aus Pipes und beim FIFO werden immer Daten von Anfang an zurückgegeben, und beim Schreiben in sie werden Daten am Ende hinzugefügt. Sie unterstützen keine Dateispeicherortoperationen wie lseek().
Der Puffer einer Pipe ist begrenzt (der Pipe-Mechanismus ist im Speicher vorhanden und beim Erstellen der Pipe wird dem Puffer eine Seitengröße zugewiesen)
Was die Pipeline überträgt, ist ein unformatierter Bytestrom, der erfordert, dass sich Leser und Schreiber der Pipeline im Voraus auf das Format der Daten einigen, z. B. wie viele Bytes als Nachricht (oder Befehl oder Datensatz) usw. gelten.

FIFO hat oft mehrere Schreibprozesse und einen Leseprozess.

FIFO-Öffnungsregeln:

1. Wenn der aktuelle Öffnungsvorgang das FIFO zum Lesen öffnen soll und ein entsprechender Prozess den FIFO bereits zum Schreiben geöffnet hat, wird der aktuelle Öffnungsvorgang erfolgreich zurückgegeben. Andernfalls kann er blockiert werden, bis ein entsprechender Prozess den FIFO zum Schreiben öffnet (der aktuelle Öffnungsoperation Das Blockierungsflag ist gesetzt); oder, wird erfolgreich zurückgegeben (bei der aktuellen Öffnungsoperation ist die Blockierungsflagge nicht gesetzt).
2. Wenn der aktuelle Öffnungsvorgang das FIFO zum Schreiben öffnen soll und ein entsprechender Prozess den FIFO bereits zum Lesen geöffnet hat, wird der aktuelle Öffnungsvorgang erfolgreich zurückgegeben. Andernfalls kann er blockiert werden, bis ein entsprechender Prozess den FIFO zum Lesen öffnet (der aktuelle Öffnungsoperation Das Blockierungsflag ist gesetzt); oder es wird ein ENXIO-Fehler zurückgegeben (das Blockierungsflag ist für die aktuelle Öffnungsoperation nicht gesetzt).

Kurz gesagt, sobald das Blockierungsflag gesetzt ist und mkfifo aufgerufen wird, um es einzurichten, müssen die Lese- und Schreibvorgänge an beiden Enden der Pipe separat geöffnet werden. Wenn keine Seite geöffnet ist, wird sie blockiert open heißt.

Daten aus FIFO lesen:

Konvention: Wenn ein Prozess das Öffnen des FIFO blockiert, um Daten aus dem FIFO zu lesen, dann wird der Lesevorgang innerhalb des Prozesses als Lesevorgang mit gesetztem Blockierungsflag bezeichnet. (Das bedeutet, dass ich jetzt eine berühmte Pipe öffnen möchte, um Daten zu lesen!)

Wenn ein Prozess schreibt, um den FIFO zu öffnen, und sich derzeit keine Daten im FIFO befinden (es kann verstanden werden, dass beide Enden der Pipe eingerichtet wurden, aber das Schreibende noch nicht mit dem Schreiben von Daten begonnen hat!)

1. Dann wird der Lesevorgang mit gesetztem Blockierungsflag immer blockiert (d. h. blockiert und wartet auf Daten. Es verbraucht keine CPU-Ressourcen. Diese Prozesssynchronisierungsmethode ist für die CPU sehr effizient.)
2. Für Lesevorgänge ohne Setzen des Blockierungsflags wird -1 zurückgegeben und der aktuelle errno-Wert ist EAGAIN, was Sie daran erinnert, es später noch einmal zu versuchen.

Für Lesevorgänge mit gesetztem Blockierungsflag (siehe Konvention oben)
Es gibt zwei Gründe für eine Behinderung

1. FIFO内有数据，但有其它进程在读这些数据
2. FIFO内没有数据。解阻塞的原因则是FIFO中有新的数据写入，不论信写入数据量的大小，也不论读操作请求多少数据量。

读打开的阻塞标志只对本进程第一个读操作施加作用，如果本进程内有多个读操作序列，则在第一个读操作被唤醒并完成读操作后，其它将要执行的读操作将不再阻塞，即使在执行读操作时，FIFO中没有数据也一样,此时，读操作返回0。

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

向FIFO中写入数据：

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

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

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

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

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

简单描述下上面设置了阻塞标志的逻辑
设置了阻塞标志

if (buf_to_write then
 if ( buf_to_write > system_buf_left ) //保证写入的原子性,要么一次性把buf_to_write全都写完，要么一个字节都不写！
 then
  block ;
  until ( buf_to_write else
  write ;
 fi
else
 write ; //不管怎样，就是不断写，知道把缓冲区写满了才阻塞
fi

管道写端 pipe_read.c

/pipe_read.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#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, '\0', sizeof(buffer));

printf("Process %d opeining FIFO O_RDONLY\n", getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d\n", getpid(), pipe_fd);

if (pipe_fd != -1)
{
do{
res = read(pipe_fd, buffer, BUFFER_SIZE);
bytes += res;
printf("%d\n",bytes);
}while(res > 0);
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}

printf("Process %d finished, %d bytes read\n", getpid(), bytes);
exit(EXIT_SUCCESS);
}

管道读端 pipe_write.c

//pipe_write.c

#include   
#include   
#include   
#include   
#include   
#include   
#include   
  
#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_NAME, 0777);  
        if (res != 0)  
        {  
            fprintf(stderr, "Could not create fifo %s\n", FIFO_NAME);  
            exit(EXIT_FAILURE);  
        }  
    }  
  
    printf("Process %d opening FIFO O_WRONLY\n", getpid());  
    pipe_fd = open(FIFO_NAME, open_mode);  
    printf("Process %d result %d\n", getpid(), pipe_fd);  
  
   //sleep(20);
    if (pipe_fd != -1)  
    {  
        while (bytes if (res == -1)  
            {  
                fprintf(stderr, "Write error on pipe\n");  
                exit(EXIT_FAILURE);  
            }  
            bytes += res;  
        printf("%d\n",bytes);
        }  
        close(pipe_fd);  
    }  
    else  
    {  
        exit(EXIT_FAILURE);  
    }  
  
    printf("Process %d finish\n", getpid());  
    exit(EXIT_SUCCESS);  
}

本文介绍了Named Pipes (FIFO) in Linux-Systemen的方法，包括有名管道的创建、打开、读写、关闭和删除等方面。通过了解和掌握这些知识，我们可以更好地使用有名管道（FIFO）来实现进程间通信，提高系统的性能和可靠性。当然，Named Pipes (FIFO) in Linux-Systemen还有很多其他的特性和用法，需要我们不断地学习和探索。希望本文能给你带来一些启发和帮助。

Das obige ist der detaillierte Inhalt vonNamed Pipes (FIFO) in Linux-Systemen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!