IMPORTANT: Per accedir als fitxer de subversion: http://acacha.org/svn (sense password). Poc a poc s'aniran migrant els enllaços. Encara però funciona el subversion de la farga però no se sap fins quan... (usuari: prova i la paraula de pas 123456)

Introducció

La gestió de processos és una part molt important dels sistemes operatius moderns. Com sabeu, el sistema operatiu és l'encarregat de gestionar els recursos necessaris que permeten executar organitzadament els processos d'un sistema informàtic.

Les següents funcions són responsabilitat del sistema operatiu:

Per tal d'assolir aquest objectius, el sistema operatiu ha de mantenir una estructura de dades per a cada procés que descrigui l'estat del procés i els recursos que utilitza. Aquesta estructura, s'anomena bloc de control de procés.

Processos i fils d'execució

En informàtica, un procés és una instància d'una aplicació que està essent executada per una computadora. Cal tenir en compte, que una aplicació o programa és solament una col·leció passiva d'instruccions que no esdevenen un procés fins que el programa és executat.

! Des del punt de vista del sistema operatiu, un procés no és res més que un conjunt de recursos que s'han de gestionar per tal d'executar un programa.
Sabíeu que...
Una sola aplicació pot arribar a executar múltiples processos al mateix temps (p. ex., el servidor web Apache pot tenir múltiples processos 
executant-se alhora, en espera de rebre peticions de pàgines web).

Concurrència de processos

Els primers sistemes informàtics eren monoprocés, és a dir, només es podia executar un procés alhora. Fins que aquest procés no acabava, no es podia atendre a cap altre procés. En aquest tipus de sistemes, la planificació es duia a terme de forma senzilla utilitzant cues FIFO.

FIFO: vp:FIFO En els primers sistemes monoprocés, la planificació de les execucions de programes es feien utilitzant cues. Els 
administradors del sistema, programaven l'execució de programes col·locant-los en una cua d'espera. Aquest tipus de programació se l'anomena  
programació per lots o Batch.

Actualment, la majoria de sistemes operatius moderns són multiprocés, és a dir, permetent executar múltiples aplicacions al mateix temps. Aquesta característica també es coneguda com a concurrència de processos o multiprogramació.

La concurrència real de processos pot esdevenir de 2 formes diferents:

  • Sistemes operatius multitasca: Els processos aparentment s'executen al mateix temps tot i que realment, en un instant concret de temps, només hi ha un procés que estigui utilitzant la CPU. Un ordinador amb un sol processador executa les instruccions una a una, però pot intercalar diferents processos utilitzant una multiplexació en temps (Time-sharing), procés que a certes velocitats produeix la "il·lusió" que el sistema treballa amb diferents processos al mateix temps.
  • Sistemes operatius multiprocés: l'única forma de tenir un sistema multiprocés real és tenir més d'una CPU. Els sistemes operatius que suporten treballar amb més d'una CPU a l'hora s'anomenen multiprocés. Aquests sistemes també permeten al mateix temps la concurrència de processos en un mateix processador.
Tingueu en compte que
Als sistemes operatius multitasca també se'ls anomena multiprogramats i als sistemes monoprocés se'ls anomena monoprogramats

TODO: Inserir una gràfica amb un exemple d'execucio de dos programes en un sistema monoprogramat i en un sistema multiprogramat!


Recursos:

Canvi de context

TODO

El bloc de control de procés

Els sistemes operatius necessiten gestionar els processos i per tant, necessiten una estructura de dades per representar i emmagatzemar tota la informació relativa a un procés del sistema:

El Bloc de Control de Procés (BCP), també conegut per les inicials angleses PCB (Proces Control Block),  és l'estructura de dades on s'agrupa tota la 
informació que necessita conèixer un sistema operatiu sobre un procés.

Cada procés té el seu propi BCP, i aquesta estructura de dades es guardada en memòria durant tot el seu cicle de vida. La implementació exacte de cada BCP depèn de cada sistema operatiu però podem considerar que tots els sistemes comparteixen una serie de dades comunes:

  • Identificador del procés: També conegut com a PID (Process Identificator en anglès). És un valor numèric que identifica de forma única un procés
  • Estat del procés: L'estat actual del procés segons el model d'estats de processos del sistema operatiu.
  • Registres del processador: Són les dades que necessita el processador per executar el procés i defineixen l'entorn del procés. Cal emmagatzemar-los per tal de permetre les operacions de canvi de context.
    • Comptador de Programa (PC Program Counter): El registre de CPU mésAdreça de la pròxima instrucció a executar.
  • Espai d'adreces de memòria del procés: Els programes en execució necessiten memòria per a guardar el seu codi, les seves dades i la pila d'execució.
  • Prioritat del procés: (en el cas que s'utilitzi)
  • Llista de recursos assignats al procés (descriptors de fitxers, sockets oberts, etc.)
  • Estadístiques del procés:
  • Dades del propietari del procés
  • Permisos assignats.
  • Senyals pendents de ser processades.
NOTA: Es tracta d'una estructura de dades que emmagatzema les metadades d'un procés necessàries per a la seva administració

En sistemes Unix que utilitzen el sistema de fitxers virtual proc, podem accedir a la informació que el sistema operatiu té del processos del sistema accedint a la carpeta:

/proc/PID_del_procés

Per exemple si executem:

$ sleep 500&
[1] 3009

Podem consultar les dades del procés accedint a la carpeta /proc/3009:

$ cd /proc/3009

Si feu un ls veureu diversos fitxers amb la informació del procés.

$ cat cmdline 
sleep500




TODO --> PCB i sistemes /proc --> http://acacha.dyndns.org/mediawiki/index.php/Processos_Linux#Fitxers_de_la_carpeta_proc

Fils d'execució

Un fil d'execució és una característica dels sistemes operatius moderns que permet que una aplicació realitzi varies tasques de forma concurrent utilitzant fils d'execució. En aquest tipus de sistemes, un mateix procés pot estar format per múltiples fils d'execució. Els diferents fils que formen part d'un mateix procés, comparteixen certs recursos com l'espai de memòria, els arxius oberts, els permisos, etc. En canvi, cada fil consta de les seves pròpies instruccions, la seva pròpia pila d'execució, s'executen a diferents velocitats (cada fil té el seu propi registre PC) i tenen el seu propi estat d'execució.

Els fils d'execució, també són coneguts com a processos lleugers. L'origen del nom rau en el fet que els fils d'execució consumeixen menys recursos de sistema que els processos.

La paraula fil d'execució prové del terme anglès thread.

La tècnica de programació amb fils d'execució s'anomena Multithreading i permet simplificar el dissenys d'aplicacions concurrents i millor el rendiment de la creació de processos.

La majoria de llenguatges de programació moderns, disposen de llibreries específiques per tal de programar amb fils i altres com C o C++ han d'utilitzar les crides de sistema que donen aquest suport.

Un parell d'exemples típics on s'utilitzen fils són

  • Aplicacions gràfiques: Un fil s'encarrega de la interfície gràfica d'usuari mentrestant un altre realitza les operacions.
  • Aplicacions client/servidor: el servidor crea múltiples fils per tal de donar servei a múltiples clients alhora.

En sistemes POSIX hi ha 2 llibreries per a treballar amb fils d'execució:

  • Native POSIX Thread Library per a Linux
  • POSIX Threads standard
TODO
Fils d'execució vs processos

Diferències:

   * Els processos són independents entre ells i en canvi els fils estan relacionats i comparteixen recursos ("són germans bessons"). Quan es crea un procés fill amb fork, el fill és una còpia però és independent del pare.
   * Els canvis de context entre fils són més ràpids que els canvis de context entre processos. Els fils no necessiten crear nous espais de memòria sinó que aprofiten gran part dels ja existents dels seus germans (aproximadament és un ordre de magnitud més ràpid)
   * Els processos són inherentment més segurs que els fils
   * Un procés es pot considerar un procés MonoFil

Gestió de processos a Unix

Cicle de vida d'un procés

La creació de processos és una tasca que correspon el sistema operatiu del sistema. Les aplicacions que s'executen en l'espai d'usuari del sistema, no poden crear directament nous processos i han de delegar aquesta tasca al sistema operatiu. Aquesta delegació es duu a terme directament mitjançant crides de sistema.

Tots els sistemes operatius ofereixen funcions de sistema que permeten gestionar el cicle de vida d'un procés. En sistemes Unix-like tenim les següents crides:

  • Crear un procés: fork()
  • Destruir un procés: exit()
  • Esperar l'acabament d'un fill: wait()
Sabíeu que...
Unix-like

De forma equivalent, tots els llenguatges de programació disposen de funcions equivalents que permeten treballar amb aquestes crides de sistema. En aquest apartat veurem les funcions de PHP que ens permeten gestionar el cicle de vida d'un procés.

Jerarquia de processos Unix

A Unix, un procés pot crear un altre procés mitjançant la crida al sistema fork.

Aquest sistema de generació de processos crea el que es coneix com larbre de processos del sistema. Tots els processos del sistema tenen un procés pare, formant una estructura de dades arbre. L'arrel d'aquest arbre és el procés inicial del sistema, que en Unix se sol anomenar procés init. Podeu consultar l'arbre de processos d'un sistema Unix amb l'ordre pstree.

El procés init és considerat el primer procés d'usuari del sistema i per aquest raó se li assigna l'identificador de procés (PID) 1. Aquest procés és executat pel [[Nucli_del_sistema_operatiu |nucli del sistema operatiu] (kernel en anglès) del sistema operatiu durant l'arrancada del sistema.

La gestió de tots els processos d'un sistema la duu a terme el nucli del sistema operatiu. El procés del nucli encarregat d'aquesta tasca és conegut com a Planificador. És diu que aquest procés té l'identificador de procés 0 (PID 0) per que la seva execució es prèvia a l'execució del procés init (PID 1).

El planificador, també és conegut pels termes anglesos swapper o scheduler

TODO--> explicar el procés d'arrancada d'un sistema Unix. Bios, gestor d'arrancada (GRUB), kernel, procés init, serveis del sistema, línia de comandes i/o entorn gràfic.

Ho tinc a:

Les crides de sistema fork(), exit() i wait()

fork()

La crida de sistema fork s'utilitza en sistemes operatius UNIX (o Unix-like) compatibles amb POSIX. Aquesta crida permet que un procés es dupliqui, per exemple, per realitzar un altre operació. El procés original és anomenat procés pare i el nou procés és anomenat procés fill. Sovint, les operacions realitzades pel procés fill és realitzen de forma paral·lela a les realitzades pel procés pare.

Podem considerar la crida de sistema fork com el mecanisme més bàsic del que disposa el sistema operatiu per tal de crear nous processos.

La relació entre els processos fills i pares és una relació de filiació o herència. Tots els atributs del procés pare (com per exemple, els drets d'accés al sistema de fitxers) són tramesos al procés fill.

Vegem un exemple de com funciona fork() en PHP:

<?php

$pid = pcntl_fork();
if ($pid == -1) {
     //Error
     die('Error a l'utilitzar la funció fork');
} else if ($pid) {
     // Aquí va el codi del procés pare

} else {
     // Aquí va el codi del procés fill
}
?>

Al procés fill, la crida fork torna el valor 0 i al procés pare, torna el valor de l'identificador de procés (PID) del nou fill acabat de crear. És molt important tenir en compte que en aquest exemple, tot i tractar-se d'un únic programa amb un codi font únic, a l'executar fork() estem creant dos processos que s'executen de forma concurrent !

El procés pare pot esperar a que l'execució del procés fill acabi, o continuar la seva execució en paral·lel a l'execució del procés fill. Per tant, la crida fork() és el mecanisme de concurrència més senzill que ofereixen els sistemes operatius Unix.

Sabíeu que... :
Fork Bomb: Bomba Fork
 Unix: (){ :|:& };:
 Windows: 
  :s
  START %0
  GOTO :s
ForkGraphic.png

Cal tenir en compte que el procés fill, és gairebé una còpia exacte del seu pare i n'hereta les següents dades:

  • Dades del propietari del procés: Comparteixen el mateix usuari i grup,
  • Entorn d'execució: les variables d'entorn són compartides entre pare i fill, i s'executen en el mateix directori de treball.
  • Taula de descriptors de fitxers: tots dos processos comparteixen les mateixes entrades i sortides (E/S).

Tant el pare com el fill comparteixen el mateix codi font. El procés pare o el fill poden executar un altre codi, utilitzant la crida de sistema exec().

TODO!! BCP!!

exit()

Tots els sistemes operatius tenen una crida de sistema que permet als processos finalitzar la seva execució. Normalment aquesta crida s'anomena exit. Un cop finalitza un procés, el sistema operatiu allibera els recursos que estava utilitzant aquell procés (espai de memòria, fitxers, etc.) per tal que puguin ser utilitzats per altres processos.

NOTA: La funció exit() permet acabar un procés des del seu codi font. La comanda kill ens permetrà aturar un procés de forma asíncrona des de 
fora del procés.

Les funcions que ofereixen els diferents llenguatges de programació també se solen anomenar exit. Per exemple, tant en C com en PHP podem utilitzar la funció exit()

<?php

$filename = '/cami/al/fitxer';
$file = fopen($filename, 'r')
    or exit("No s'ha pogut obrir el fitxer ($filename)");
?>
! En PHP també podem utilitzar com a equivalent a exit(), la funció die().

Els processos al finalitzar poden retornar un valor. A aquest valor se l'anomena estat de la sortida (exit status) i indica quin a estat la raó de l'acabament del procés.

Existeix un conveni a l'hora d'indicar l'estat de sortida d'un procés. El valor 0 (valor per defecte de la funció exit()) indica que l'acabament del 
procés ha estat normal. En canvi, qualsevol altre valor indicarà una acabament degut a un error. El valor de l'estat de sortida es pot utilitzar per 
tal de diferenciar diferents tipus d'error.

Vegem alguns exemple d'us de l'estat de sortida d'un procés amb la funció exit() de PHP:

Programa que finalitza correctament:

<?php
exit;
exit();
exit(0);
<?>

Programa que finalitza amb error

<?php
exit(1);
exit(0376); //Format octal

?>

Cal tenir en compte que en molts llenguatges de programació com PHP, l'acabament d'un procés pot ser explícit al fer ús de la funció exit()) o implícit, en arribar al final del codi font.

wait()

Un cop s'ha finalitzat un procés, en sistemes operatius Unix encara es guarda certa informació del procés mort. Aquesta informació és manté fins que el procés pare que ha invocat el procés que acaba de morir la reculli. Aquesta tasca és realitza mitjançant la crida de sistema wait.

Les relacions d'afiliació entre processos i els seus diferents estats poden provocar l'existència de processos especials:

  • Procés orfe: Un procés orfe, és aquell procés el pare del qual ha finalitzat la seva execució. A Unix tots els processos, excepte el procés init, han de tenir un procés pare. Per aquesta raó, el planificador del sistema realitza periòdicament un cerca de processos orfes i els hi assigna com a pare el procés init. Tot i el "nou" pare que tenen aquest processos, se'ls considera processos orfes.
  • Procés zombie: els processos fills que acaben la seva execució però que el seu estat de sortida ha estat ignorat pel procés pare són anomenats processos zombie. Això pot succeir per un mal funcionament del pare.

Tots els sistemes operatius tenen mecanismes per controlar aquests casos especials i evitar d'aquesta forma inconsistències en la gestió de processos.

Tingueu en compte que...
Els processos fills creats amb la crida fork() hereten la majoria de propietats dels seus pares. Això inclou la resposta certes senyals 
del sistema que provoquen que si matem un procés pare, també aturem els seus fills (efecte que podeu observar si tanqueu una terminal on s'està 
executant un procés)

TODO ---> NOHUP!!! http://acacha.dyndns.org/mediawiki/index.php/Processos_Linux#nohup

Ara que ja coneixem totes les crides de sistema per a gestionar el cicle de vida d'un procés (i les funcions PHP equivalents) vegem quin és l'esquelet complet d'un codi d'exemple d'execució concurrent de dos processos (fill i pare)

Fork.png
<?php

$pid = pcntl_fork();
if ($pid == -1) {
     //Error
     die('Error a l'utilitzar la funció fork');
} else if ($pid) {
     // Aquí va el codi del procés pare
    ...
    ...
    //Es recull la informació del procés fill quan finalitza (evita els processos Zombie).
    pcntl_wait($status); 
    //La variable status conté l'estat de sortida del procés fill
    exit;
 } else {
     // Aquí va el codi del procés fill
     ...
     ...
     exit;
}
?>

Recursos:

Execució de programes externs al codi font. La crida de sistema exec()

Les funcions exec en sistemes operatius Unix-like o compatibles amb POSIX són una col·lecció de funcions que permeten l'execució d'aplicacions externes. Aquest tipus de funcions, substitueixen el procés que les executa, per un altre programa que es passat com argument a la funció exec.

És molt important tenir en compte, que no es crea cap nou procés sinó que es substitueix un procés per un altre. El nou procés executat amb exec tindrà el mateix identificador de procés (PID) que el procés que a executat exec.

La majoria de terminals de Unix, també ofereixen una comanda exec. Aquesta comanda forma part de la shell () i substitueix la terminal on l'executem per la comanda o aplicació que li indiquem.

built-in command ---> Comandes que formes part de la shell. No hi ha un executable especific (al fer switch)

A Unix la crida de sistema que executa les funcions exec és execve.

A PHP podem utilitzar la funció pcntl_exec(). La seva sintaxi és:

void pcntl_exec  ( string $path  [, array $args  [, array $envs  ]] )

On:

  • path: és el camí de l'executable que volem executar o guió de Shell amb la primera línia indicant quin és l'executable a utilitzar (per exemple: #!/usr/local/bin/perl si es un script fet en perl)
  • args: és un vector de cadenes de caràcters (String) amb els paràmetres a passar a l'executable indicar al paràmetre anterior (path)
  • envs: és un vector de cadenes de caràcters (String) que es passen a l'entorn d'execució del programa. El vector esta en format nom => valor, on nom és el nom de la variable d'entorn i valor és el valor de la variable d'entorn

El següent exemple executaria la comanda ps:

<?php
pcntl_exec('/bin/ps');  
?>

I el següent exemple executaria la comanda ps amb els paràmetres aux:

<?php
$cmd = "/bin/ps";
$args = array("aux");
pcntl_exec($cmd, $args);
?>

Finalment per tal d'executar:

$  ps -eo user,pid,%cpu,vsz,tty,stat,start,time,command --sort=-%cpu

El codi seria:

<?php
$cmd = "/bin/ps";
$args = array("-eo","user,pid,%cpu,vsz,tty,stat,start,time,command","--sort=-%cpu");
pcntl_exec($cmd, $args);
?>

Vegem ara com podem simular l'execució de comandes en una terminal. El primer cas correspon a l'execució en primer terme o 'foreground (l'execució per defecte) d'una comanda:

#!/usr/bin/php5 -q
<?php

if ($_SERVER['argv'][1]==null) {
 echo "Cal especificar un paràmetre\n";
 exit();
}

$pid = pcntl_fork();
if ($pid == -1) {
     die('El fork no ha anat correctament');
} else if ($pid) {
     // Qualsevol valor de retorn diferent a zero representa el pare. 
     // Restem a l'espera de l'acabament del fill
     do {
        $ret= pcntl_wait($status);
        } while (($ret!=-1) && ($ret!=$pid));
     if ($ret == -1) echo ("Ha succeït un error al executar wait");
} else {
    // Aqui va el codi del procés fill
    //Executem la comanda que se'ns ha passat com a primer argument
    pcntl_exec($_SERVER['argv'][1]);
}

?>

La implementació és molt senzill, i només funcionarà si especifiquem tot el camí complet a la comanda i s'ignoraran els arguments de la comanda. Si anomenen al fitxer ComandaEnPrimerTerme.php un exemple vàlid podria ser:

$ ./ComandaEnPrimerTerme.php /bin/ls

I estem emulant l'execució directa de ls des de la línia de comandes.

El codi equivalent en segon terme o background seria:

#!/usr/bin/php5 -q
<?php

if ($_SERVER['argv'][1]==null) {
 echo "Cal especificar un paràmetre\n";
 exit();
}

$pid = pcntl_fork();
if ($pid == -1) {
     die('El fork no ha anat correctament');
} else if ($pid) {
     exit();
} else {
     // Aqui va el codi del procés fill
     //Executem la comanda que se'ns ha passat com a primer argument
     pcntl_exec($_SERVER['argv'][1]);
}

?>

Recursos:

Gestió de processos

Bla bla bla... gestió de processos en sistemes Unix Like

Ordre ps

L'ordre ps permet accedir a les dades que el sistema operatiu disposa sobre els processos en execució. Com ja hem comentat, aquestes dades es guarden al bloc de control de procés i per tant, les dades a les que podrem accedir seran les mateixes que emmagatzema aquesta estructura de dades (PID, estat del procés, estadístiques del procés, recursos utilitzats, etc.)

$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1   2844  1692 ?        Ss   16:11   0:01 /sbin/init
root         2  0.0  0.0      0     0 ?        S<   16:11   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        S<   16:11   0:00 [migration/0]
root         4  0.0  0.0      0     0 ?        S<   16:11   0:00 [ksoftirqd/0]
root         5  0.0  0.0      0     0 ?        S<   16:11   0:00 [watchdog/0]
root         6  0.0  0.0      0     0 ?        S<   16:11   0:00 [events/0]
root         7  0.0  0.0      0     0 ?        S<   16:11   0:00 [khelper]
...

Hi han diferents implementacions de la comanda ps, les quals difereixen sobretot en la forma d'utilitzar les opcions. Podem destacar però, 3 versions principals:

  1. Opcions UNIX: les opcions han d'estar totes agrupades i han d'estar precedides per un guió (-).
  2. Opcions BSD: poden estar agrupades i no utilitzen mai el guió (-).
  3. Opcions llargues de GNU: van precedides per dos guions (--)


Ordre pstree

L'ordre pstree mostra els processos en execució en forma d'arbre. S'utilitza com una alternativa a l' ordre ps perquè permet veure la jerarquia de processos en sistemes Unix. L'arrel de l'arbre es sempre el procés init.

$ pstree -p | head

init(1)-+-acpid(4948)

       |-amarokapp(11294)-+-ruby(11325)
       |                  |-{amarokapp}(11317)
       |                  |-{amarokapp}(11318)
       |                  |-{amarokapp}(11319)
       |                  |-{amarokapp}(11320)
       |                  |-{amarokapp}(11321)
       |                  `-{amarokapp}(16067)
       |-apache2(6224)-+-apache2(6305)
       |               |-apache2(6307)


Ordre top

L'ordre top mostra una llista dels processos que s'estan executant actualment. A diferència de l'ordre ps, la llista s'actualitza regularment i els processos es mostren per defecte ordenats per ordre descendent del percentatge d'ús de la CPU. L'ordre és molt útil perquè permet als administradors del sistema conèixer quins són els processos que estan consumint més recursos en un moment determinat.

L'ordre mostra la quantitat de CPU i de memòria que està sent utilitzada, així com altres informacions referents als processos en execució. Algunes versions de la comanda top permeten configurar els resultats mostrats per l'ordre (per exemple canviar l'ordre de les columnes, la ordenació, etc.).

Fitxer:ComandaTop.png

Ordres jobs, bg, fg, wait i sleep

Una línia d'ordres de Unix (també coneguda com a terminal) pot executar aplicacions seqüèncialment (monoprogració) o concurrentment (multiprogramació). Podem distingir 2 tipus de tasques quan les executem en una terminal:

  • Tasques en primer pla:bloquegen la terminal durant la seva execució. També són conegudes com tasques foreground (terme anglès per a primer pla)
  • Tasques en segon pla: no bloquegen la terminal i permeten executar altres tasques durant la seva execució. També són conegudes com tasques foreground (terme anglès per a segon pla)
Sabíeu que...
Els processos que s'executen en una terminal sovint també es coneixen com a tasques o jobs

El mode per defecte en que s'executa una ordre a la línia d'ordres és en primer pla. Per executar una comanda en segon pla utilitzem l'operador &

$ ordre &

Per comprovar-ne el funcionament, podeu utilitzar l'ordre sleep. Aquesta ordre s'espera un temps especificat en segons abans de finalitzar la seva execució. Per exemple:

$ sleep 10

Bloquejarà la terminal durant 10 segons. Si executeu:

$ sleep 10&

Ara la terminal no és bloqueja i us apareixerà un missatge similar a:

[1] 13578

On [n] ([1] en l'exemple) és el número de procés que s'està executant en segon terme i 13578 és el PID del procés.

Podeu executar diversos cops la comanda sleep i consultar la taula de treballs (jobs) en segon terme utilitzant l'ordre jobs:

$ sleep 10&
[1] 13691
$ sleep 10&
[2] 13692
$ sleep 10&
[3] 13695
$ sleep 10&
[4] 13696

$ jobs
[1]   Running                 sleep 10 &
[2]   Running                 sleep 10 &
[3]-   Running                 sleep 10 &
[4]+   Running                 sleep 10 &

En qualsevol moment podeu aturar un procés amb la combinació de tecles Ctrl+Z (envia la senyal aturar). Escriviu:

$ sleep 50

I atureu la comanda amb la combinació Ctrl+Z (envia la senyal aturar). Apareixerà el següent per pantalla:

[1]+  Stopped                 sleep 50 

L'ordre sleep ha quedat suspesa tal i com podeu veure executant:

$ jobs
[1]+  Stopped                 sleep 50

Podeu reprendre la seva execució en primer pla amb:

$ fg sleep

O la podeu reprendre en segon pla amb:

$ bg sleep 
[1]+ sleep 50 &



Ordres at i cron

Prioritat de processos. Ordres nice i renice

L'ordre nice s'utilitza en sistemes operatius UNIX i Unix-like per modificar la prioritat dels processos.Utilitza directament la crida de sistema del mateix nom. Els valors de prioritat van de -20 a 19.

L'ordre renice permet modificar la prioritat d'un procés que ja està en execució.

El resultat exacte de les comandes nice i renice en la execució d'un procés depèn els detalls de la implementació del planificador del sistema operatiu.


TODO: Explicar sistemes operatius amb cues de prioritat...

Ordre time

L'ordre time permet conèixer el temps exacte que triga en executar-se una aplicació.'utilitza en sistemes operatius Unix o UNIX-like per a obtenir estadístiques sobre el temps d'execució d'una aplicació.

Vegem un exemple que pot ser il·lustratiu de com s'executen els processos en un sistema operatiu:

$ time sleep 10

real	0m10.004s
user	0m0.004s
sys	0m0.000s

El resultat pot semblar incongruent però es del tot correcte. La comanda sleep 10 atura el procés (en aquest cas la terminal) durant 10 segons. El sistema a necessitat 0.004s per aturar la terminal. Durant la resta de l'execució d'sleep la comanda no utilitza cap recurs del sistema (només roman en espera).

Ordre watch

L'ordre watch executa la comanda especificada repetidament i mostra els seu resultat per la sortida estàndard de forma que es poden observar les modificacions del resultat de l'ordre al llarg del temps.

Per defecte el temps de repetició és cada 2 segons però aquest valor es pot canviar amb el paràmetre -n. Com la comanda s'executa amb sh -c, cal posar la comanda completa a executar juntament amb els seus paràmetres entre cometes (").

El podem utilitzar per exemple, per simular la comanda top, combinant les comandes watch i ps:

$ watch "ps -eo user,pid,%cpu,vsz,tty,stat,start,time,command --sort=-%cpu"

Model d'estats Unix

Unix utilitza un model de 7 estats

UNIX com la majoria de sistemes operatius moderns, utilitza un model de 7 estats on intervé el concepte d'intercanvi (swapping) de memòria virtual. Els processos poden romandré en espera de ser executats o aturats en memòria principal (sovint memòria RAM) o en memòria secundària (sovint al disc dur del sistema).

Segons el manual de l'ordre ps, existeixen 6 estats possibles de procés:

  • En execució (R del terme anglès Running): La CPU del sistema està executant el procés. En un instant concret de temps, si el sistema és monoprocessador, només un procés pot esta fent ús de la CPU.
  • En espera (Waiting): El procés esta esperant un esdeveniment o un recurs d'E/S. Linux diferencia dos tipus de processos en espera:
    • En espera interrumpible (S, Waiting interruptible): Són processos que estan en espera i que poden ser interromputs per senyals.
    • En espera no interrumpible (D. Waiting uninterruptible): Procés en espera que no pot ser interromput.
  • Atura (T, Stopped): El procés esta aturat segurament per una senyal. Per exemple un procés que esta sent depurat per un depurador.
  • Zombie (Z): és un procés finalitzat però que encara està la seva estructura de dades (BCP) en memòria.
  • Terminat (X): El procés ha finalitzat.

A aquest esta cal afegir-li l'estat creat, que indica que un procés ha estat acabat de crear però que encara no està disponible per a la seva execució.

A Linux també es diferencia entre els processos que estan sent executats en mode nucli o en mode usuari

Recursos