Paip bernama (FIFO) dalam sistem linux

Sistem Linux ialah sistem pengendalian yang menyokong pelaksanaan serentak pelbagai tugas Ia boleh menjalankan berbilang proses pada masa yang sama, dengan itu meningkatkan penggunaan dan kecekapan sistem. Walau bagaimanapun, jika pertukaran data dan kerjasama diperlukan antara proses ini, beberapa kaedah komunikasi antara proses (IPC) perlu digunakan, seperti isyarat, baris gilir mesej, memori kongsi, semaphore, dsb. Antaranya, paip terkenal (FIFO) adalah kaedah IPC yang agak mudah dan berkuasa Ia membolehkan dua atau lebih proses menghantar data melalui fail tanpa mengambil berat tentang kandungan dan format fail. Artikel ini akan memperkenalkan kaedah paip bernama (FIFO) dalam sistem Linux, termasuk penciptaan, pembukaan, membaca, menulis, menutup dan memadam paip terkenal.

Satu had utama penggunaan paip yang tidak dinamakan ialah ia tidak mempunyai nama, jadi ia hanya boleh digunakan untuk komunikasi antara proses dengan pertalian Had ini telah diatasi selepas pengenalan paip bernama (paip bernama atau FIFO). FIFO berbeza daripada paip kerana ia menyediakan nama laluan yang dikaitkan dengannya, yang wujud dalam sistem fail dalam bentuk fail FIFO. Dengan cara ini, walaupun tidak ada pertalian dengan proses yang mencipta FIFO, selagi laluan boleh diakses, mereka boleh berkomunikasi antara satu sama lain melalui FIFO (antara proses yang boleh mengakses laluan dan proses yang mencipta FIFO). Oleh itu, tiada korelasi melalui Proses FIFO juga boleh bertukar-tukar data. Perlu diingat bahawa FIFO mengikut ketat keluar dahulu (masuk dahulu keluar dahulu) Membaca dari paip dan FIFO sentiasa mengembalikan data dari awal, dan menulis kepada mereka menambah data ke penghujung. Mereka tidak menyokong operasi lokasi fail seperti lseek().
Penampan paip adalah terhad (mekanisme paip wujud dalam ingatan, dan saiz halaman diperuntukkan untuk penimbal apabila paip dibuat)
Perkara yang dihantar oleh saluran paip ialah strim bait yang tidak diformat, yang memerlukan pembaca dan penulis saluran paip untuk bersetuju dengan format data terlebih dahulu, seperti bilangan bait yang dikira sebagai mesej (atau arahan, atau rekod), dsb.

FIFO selalunya mempunyai pelbagai proses penulisan dan satu proses membaca.

Peraturan pembukaan FIFO:

1. Jika operasi terbuka semasa adalah untuk membuka FIFO untuk membaca, jika proses yang sepadan telah membuka FIFO untuk menulis, operasi terbuka semasa akan berjaya kembali jika tidak, ia mungkin disekat sehingga proses yang sepadan membuka FIFO untuk menulis ( operasi terbuka semasa Bendera menyekat ditetapkan); atau, kembali berjaya (operasi terbuka semasa tidak mempunyai set bendera menyekat).
2. Jika operasi terbuka semasa adalah untuk membuka FIFO untuk menulis, jika proses yang sepadan telah membuka FIFO untuk membaca, operasi terbuka semasa akan berjaya kembali jika tidak, ia mungkin disekat sehingga proses yang sepadan membuka FIFO untuk membaca ( operasi terbuka semasa Bendera penyekatan ditetapkan); atau, ralat ENXIO dikembalikan (bendera penyekatan tidak ditetapkan untuk operasi terbuka semasa).

Ringkasnya, dalam satu ayat, sebaik sahaja bendera penyekat ditetapkan dan mkfifo dipanggil untuk menetapkannya, bacaan dan tulisan pada kedua-dua hujung paip mesti dibuka secara berasingan Jika kedua-dua belah tidak terbuka, ia akan disekat apabila terbuka dipanggil.

Baca data dari FIFO:

Konvensyen: Jika proses menyekat pembukaan FIFO untuk membaca data daripada FIFO, maka operasi baca dalam proses dipanggil operasi baca dengan set bendera menyekat. (Maknanya saya sekarang nak buka paip terkenal untuk baca data!)

Jika proses menulis untuk membuka FIFO, dan pada masa ini tiada data dalam FIFO (boleh difahami bahawa kedua-dua hujung paip telah ditubuhkan, tetapi hujung penulisan belum mula menulis data lagi!)

1. Kemudian untuk operasi baca dengan set bendera menyekat, ia akan sentiasa disekat (iaitu, disekat dan menunggu data. Ia tidak menggunakan sumber CPU. Kaedah penyegerakan proses ini sangat cekap untuk CPU.)
2. Untuk operasi baca tanpa menetapkan bendera menyekat, -1 dikembalikan, dan nilai errno semasa ialah EAGAIN, mengingatkan anda untuk mencuba lagi kemudian.

Untuk operasi baca dengan set bendera menyekat (lihat konvensyen di atas)
Terdapat dua sebab untuk halangan

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);  
}

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

Atas ialah kandungan terperinci Paip bernama (FIFO) dalam sistem linux. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!