Pipa adalah media untuk komunikasi antar proses. Satu proses menulis data ke pipa, dan proses lain membaca data dari pipa. Pada artikel ini, kita akan melihat bagaimana fungsi pipe() digunakan untuk mengimplementasikan konsep menggunakan bahasa C.
Tentang Pipa
Di dalam pipa, data disimpan dalam urutan FIFO, yang berarti menulis data ke salah satu ujung pipa secara berurutan dan membaca data dari ujung pipa yang lain dalam urutan yang sama.
Jika ada proses yang membaca dari pipa, tetapi tidak ada proses lain yang belum menulis ke pipa, maka read akan mengembalikan akhir file. Jika suatu proses ingin menulis ke pipa, tetapi tidak ada proses lain yang terpasang pada pipa untuk membaca, maka ini adalah kondisi kesalahan, dan pipa menghasilkan sinyal SIGPIPE.
File Header
#termasukSintaksis
ke dalampipa(ke dalamfiledes[2])
Argumen
Fungsi ini mengambil argumen tunggal, array dua bilangan bulat ( filedes ). file[0] digunakan untuk membaca dari pipa, dan filedes[1] digunakan untuk menulis ke pipa. Proses yang ingin membaca dari pipa harus ditutup file [1], dan proses yang ingin menulis ke pipa harus ditutup file[0] . Jika ujung pipa yang tidak perlu tidak ditutup secara eksplisit, maka end-of-file(EOF) tidak akan pernah dikembalikan.
Mengembalikan nilai
Pada kesuksesan, pipa() mengembalikan 0, untuk kegagalan fungsi mengembalikan -1.
Secara piktorial, kita dapat merepresentasikan pipa() fungsi sebagai berikut:
Di bawah ini adalah beberapa contoh yang menggambarkan cara menggunakan fungsi pipa dalam bahasa C.
Contoh 1
Dalam contoh ini, kita akan melihat bagaimana fungsi pipa bekerja. Meskipun menggunakan pipa dalam satu proses tidak terlalu berguna, tetapi kita akan mendapatkan ide.
// Contoh1.c#termasuk
#termasuk
#termasuk
#termasuk
ke dalamutama()
{
ke dalamn;
ke dalamfiledes[2];
arangpenyangga[1025];
arang *pesan= 'Halo Dunia!';
pipa(filedes);
menulis(filedes[1],pesan, strlen (pesan));
jika ((n=Baca(filedes[0],penyangga, 1024 ) ) > = 0) {
penyangga[n] = 0; //mengakhiri string
printf ('baca %d byte dari pipa:'%S' ',n,penyangga);
}
lain
kesalahan ('Baca');
keluar (0);
}
Di sini kita pertama kali membuat pipa menggunakan pipa() fungsi kemudian ditulis ke pipa menggunakan gading [1] akhir. Kemudian, data telah dibaca menggunakan ujung pipa yang lain, yaitu file[0] . Untuk membaca dan menulis ke file, kami biasa Baca() dan menulis() fungsi.
Contoh2
Dalam contoh ini, kita akan melihat bagaimana proses induk dan anak berkomunikasi menggunakan pipa.
// Contoh2.c#termasuk
#termasuk
#termasuk
#termasuk
#termasuk
ke dalamutama()
{
ke dalamfiledes[2],nbyte;
pid_t kekanak-kanakan;
arangrangkaian[] = 'Halo Dunia! ';
arangreadbuffer[80];
pipa(filedes);
jika((anak kecil=garpu()) == -1)
{
kesalahan ('garpu');
keluar (1);
}
jika(anak kecil== 0)
{
Menutup(filedes[0]);//Proses anak tidak membutuhkan ujung pipa ini
/* Kirim 'string' melalui sisi keluaran pipa */
menulis(filedes[1],rangkaian, ( strlen (rangkaian)+1));
keluar (0);
}
lain
{
/* Proses induk menutup sisi keluaran pipa */
Menutup(filedes[1]);// Proses induk tidak membutuhkan ujung pipa ini
/* Membaca string dari pipa */
nbyte=Baca(filedes[0],readbuffer, ukuran dari(readbuffer));
printf ('Baca string: %s',readbuffer);
}
kembali(0);
}
Pertama, satu pipa telah dibuat menggunakan fungsi pipa kemudian proses anak telah bercabang. Kemudian, proses anak menutup ujung baca dan menulis ke pipa. Proses induk menutup ujung tulis dan membaca dari pipa dan menampilkannya. Di sini aliran data hanya satu cara yaitu dari anak ke orang tua.
Kesimpulan:
pipa() adalah panggilan sistem yang kuat di Linux. Dalam artikel ini, kita hanya melihat aliran data satu arah, satu proses menulis, dan proses lainnya membaca, membuat dua pipa kita juga dapat mencapai aliran data dua arah.