Proceso de comunicación del proceso del sistema operativo

1. Familiarizado con el comando wc

  El comando wc se usa para calcular el número de bytes, palabras o columnas de un archivo. Si el nombre del archivo no se especifica o el nombre del archivo dado es "-", el comando wc leerá los datos del dispositivo de entrada estándar.

 Parámetro:

　　c o --bytes o --chars solo muestran el número de bytes.

　　-l o --lines solo muestran el número de líneas.

　　-w o --words solo muestran el número de palabras.

　　- Ayuda en línea.

　　--version muestra información de la versión

 

2. Comunicación del proceso

 Ingrese "su" e ingrese la contraseña para la operación de una sola vez.

 

( 1 ) Tubería de lectura

gedit pip_read.c

 

　　Después de abrir el archivo, ingrese:

#include <unistd.h> 
#include <stdlib. h> 
#include <stdio.h> 
#include <str ing.h>
 int main () { 
　　FILE * read_ fp;　　　　　　  // puntero de flujo de archivo 
　　char buffer [BUFSIZ + 1 ] ;　　// Almacene el contenido leído 
　　int chars_ read; 
　　nenset (buffer, ' \ 0 ' , sizeof (buffer));    // Inicialice buf para evitar caracteres ilegibles en el archivo 
　　read_ _fp = popen ( " unane -a " , " r " );　　　　　　// Abra la tubería conectada al comando uname en modo de solo lectura, Descripción de solo lectura: la salida del programa llamado se puede leer a través de la función de biblioteca stdio fread 
　　if (read_ _fp! = NULL) { 
　　　　chars_ read = fread (buffer, sizeof ( char ), BUFSIZ, read_ fp);
　　　　if (chars_ read> 0 ) 
　　　　　　printf ( "la salida fue: - \ n% s \ n " , buffer); 
　　　　pclose (read_ fp);　　　　　　　　  // cierra la 
　　　　salida de la tubería (EXIT_ SUCCESS);　　　　　　// salida normal 
　　} 
　　　　exit (EXIT_ FAILURE);　　　　　　　/ / Lectura fallida 
}

　　Ejecutar captura de pantalla:

 

    

(2) Escribir tubería

　　Ingrese el comando "gedit pip_write.c" para abrir el archivo e ingrese:

#include <unistd.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include < string .h>
 int main () [
　　 * write_fp;
　　buffer de char [BUFSIZ + 1 ];
　　int chars_write; 
　　memset (buffer, ' \ 0 ' , sizeof (buffer)); 
　　sprintf (buffer, " Había una vez, había ... \ n " ); 
　　write_ fp = popen ( " wc -w " , " w " );　　//Escriba en la secuencia FILE * a través de la canalización (parámetro "w") 
　　if (write_ fp! = NULL) [ 
　　　　fwrite (buffer, sizeof ( char ), strlen (buffer), write_fp); // Flujo de　　datos de FILE * write_ fp Escribir en buf 
　　pclose (write_fp); 
　　salir (EXIT_SUCCESS); 
　　} 
　　salir (EXIT_FAILURE); 
}

　　 Ejecutar captura de pantalla:

 

   

3. Tubería anónima

 (1) Modelo de productor y consumidor

　　Ingrese el comando "gedit pipe.c" para abrir el archivo e ingrese:

#include <unistd.h> 
#include <stdlib. h> 
#include <stdio. h> 
#include < string .h>
 int main () [
　　int data_processed;
　　int file_ pipes [ 2 ]; // Almacene dos archivos Descriptor 0 1 
　　const  char some_data [] = " 123 " ;
　　char buffer [BUFSIZ + 1 ]; 
　　memset (buffer, ' \ 0 ' , sizeof (buffer));
　　/ * pipe crea una tubería y escribe 2 archivos en la matriz Descriptor, estas dos descripciones de archivo
　　Los descriptores están estrechamente relacionados (proceso padre-hijo), use el descriptor de archivo file_pipes [1] para escribir datos en la tubería y el descriptor de archivo file_pipe [0] para leer los datos de la tubería. * /
　　if (pipe (file_pipes) == 0 ) {
　　　　// 用 file_ pipes [1] 文件描述符 向 管道 中 写 
　　　　数据 data_ procesado = escribir (file_pipes [ 1 ], some_data, strlen (some_data)); 
　　　　printf ( " Escribió% d bytes \ n " , datos_procesados); 
　　　　data_ procesado = leer (file_pipes [ 0 ], buffer, BUFSIZ); 
　　　　printf ( " Lectura% d bytes:% s \ n " , datos_ procesados, búfer); 
　　　　salir (EXIT_SUCCESS); 
　　} 
　　salir (EXIT_FAILURE); 
}

 　　Ejecutar captura de pantalla:

     

 (2) Proceso de comunicación entre padre e hijo.

 

　　Ingrese el comando "gedit pipe_fork.c" para abrir el archivo e ingrese:

#include <unistd .h> 
#include <stdlib.h> 
#include <stdio. h> 
#include < string .h>
 int main () {
　　int data_processed;
　　int file_pipes [ 2 ];
　　const  char some_data [] = " 123 " ;
　　buffer de char [BUFSIZ + 1 ]; 
　　pid_t pid; 
　　memset (buffer, ' \ 0 ' , sizeof (buffer));
　　if (pipe (file_pipes) == 0 ) { 
　　　　pid = fork ();
　　　　if (pid == - 1 ) {　　　　　　　　　　// falla al crear el subproceso 
　　　　　　fprintf (stderr, " Falla de la bifurcación " ); 
　　　　salir (EXIT_FAILURE); 
　　　　if (pid == 0 ) {　　　　　　　　　　　　// subprocess 
　　　　　　sleep ( 1 ); 
　　　　　　data_processed = leer (file_ pipes [0], buffer, BUFSIZ); 
　　　　　　printf ( " Leer% d bytes:% s \ n " , data_processed, buffer); 
　　　　　　close (file_pipes [ 1 ]);　　　　// Cerrar la 
　　　　　　salida de 
　　　　lectura (EXIT_SUCCESS) ; 
　　　　} más {     / / viaje del padre
　　　　　　data_processed = write (file_pipes [ 1 ], some_data, strlen (some_data)); 
　　　　　　printf ( " Escribió% d bytes \ n " , datos_procesados); 
　　　　　　close (file_pipes [ 0 ]); 　　　　// 写入 成功, 关闭 写 端
　　　　} 
　　} 
　　salida (EXIT_ SUCCESS); 
}

 　　Ejecutar captura de pantalla:

 

    

 4. Tubos con nombre

(1) Creación de comandos de Shell

　　

　　Para la explicación del comando mkfifo, vea los comentarios del código a continuación

 (2) Creación del programa

#include <unistd. h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <sys / types.h> 
#include <sys / stat.h>
 int main ( int argc, char * argv [] ) {
 / * int mkfifo (const char * pathname, mode_t mode); 
nkfifo () creará un archivo FIFo especial de acuerdo con el parámetro pathnane (ruta), el archivo no debe existir, y el modo de parámetro es el permiso del archivo (modo% ~ umask) Por lo tanto, el valor de umask también afectará los permisos del archivo FIFo. * / 
int res = mkfifo ( " / my_fifo " , 0777 );
 if (res == 0 ) 
printf ( " FIFO createdn " );
salir (EXIT_SUCCESS); 
}

 (3) Lectura vacía 

cat </ fifo   // La ruta del archivo de salida después de la compilación

(4) Entrada (necesita usar otro terminal)

echo " hola, palabra " > / fifo

　　Resultado de la operación: