8.4. Pipe "anonime" e pipe con nome

Torniamo all'esempio delle pipe, poiché è molto interessante e costituisce anche un buon esempio del concetto di collegamento. Quando usate una pipe in una riga di comando, la shell crea la pipe per voi e agisce in maniera tale che il comando che precede la pipe scriva su di essa, mentre il comando che segue legge da essa: Tutte le pipe, che siano anonime (come quelle impiegate dalla shell) o provviste di nome (si veda più avanti), si comportano come delle FIFO (First In, First Out). Abbiamo già visto esempi in merito a come usare delle pipe nella shell, adesso prendiamone una in considerazione per quanto riguarda la nostra dimostrazione:

$ ls -d /proc/[0-9] | head -5
/proc/1/
/proc/2/
/proc/3/
/proc/4/
/proc/5/

Un fatto che non potrete osservare in questo esempio (in quanto avviene troppo rapidamente per essere visto) è che le azioni di scrittura sulle pipe creano un blocco. Questo significa che quando il comando ls scrive su una pipe, rimane bloccato finché un processo dal lato opposto legge dalla pipe. Per poter visualizzare questo effetto, potete creare delle pipe con nome, che, a differenza delle pipe usate dalle shell, hanno un proprio nome (cioè, sono visibili nel filesystem, mentre le pipe della shell non lo sono)[1]. Il comando per creare questo tipo di pipe è mkfifo:

$ mkfifo una_pipe
$ ls -il
total 0
    169 prw-rw-r--    1 maria       maria              0 dic 10 14:12 una_pipe|
  #
  # Come potete vedere il contatore di link è 1, e l'output mostra
  # che il file è una pipe ('p').
  #
  # Ora potete anche usare ln:
  #
$ ln una_pipe la_stessa_pipe
$ ls -il
total 0
    169 prw-rw-r--    2 maria       maria              0 dic 10 15:37 una_pipe|
    169 prw-rw-r--    2 maria       maria              0 dic 10 15:37 la_stessa_pipe|
$ ls -d /proc/[0-9] >a_pipe
  #
  # Il processo è bloccato, dato che nessuno legge dall'altro lato.
  # Digitate Ctrl-z per sospendere il processo...
  #
zsh: 3452 suspended  ls -d /proc/[0-9] > una_pipe
  #
  # ...quindi mettetelo in background:
  #
$ bg
[1]  + continued  ls -d /proc/[0-9] > una_pipe
 #
  # adesso leggete dalla pipe...
  #
$ head -5 <la_stessa_pipe
  #
  # ...e il processo di scrittura termina
  #
[1]  + 3452 done       ls -d /proc/[0-9] > una_pipe
/proc/1/
/proc/2/
/proc/3/
/proc/4/
/proc/5/
#

Allo stesso modo, anche la lettura da una pipe provoca un blocco. Se eseguiamo i comandi elencati sopra al contrario, noteremo che head si blocca, in quanto resta in attesa che qualche processo gli dia qualcosa da leggere:

$ head -5 <una_pipe
  # 
  # Il programma si blocca, sospendiamone l'esecuzione: Ctrl-z
  #
zsh: 741 suspended  head -5 < una_pipe
  #
  # Mettiamolo in background...
  #
$ bg
[1]  + continued  head -5 < una_pipe
  #
  # ...e diamogli da mangiare :)
  #
$ ls -d /proc/[0-9] >la_stessa_pipe
$ /proc/1/
/proc/2/
/proc/3/
/proc/4/
/proc/5/
[1]  + 741 done       head -5 < una_pipe
$

Nell'esempio precedente potete anche vedere un effetto non desiderato: il comando ls ha terminato l'esecuzione prima che subentrasse il comando head. Come conseguenza, il prompt vi viene restituito immediatamente, ma head verrà eseguito solo successivamente. Perciò il suo output è stato prodotto solo dopo che voi siete tornati al prompt.

Note

[1]

Esistono anche altre differenze tra i due tipi di pipe, ma sono al di là degli obiettivi di questo libro.


Tux on Star from MandrakeSoft Linux è un marchio registrato di Linus Torvalds. Tutti gli altri marchi e copyright appartengono ai rispettivi proprietari.
Se non diversamente specificato, i diritti di tutto il contenuto di queste pagine e di tutte le immagini sono proprietà di MandrakeSoft S.A. e MandrakeSoft Inc. 2002.
http://www.mandrakelinux.com/