====== Conflits d'accès aux ressources ======

Certains processus ont besoin d'accéder à des ressources -- fichiers, ports, lecteurs... Le système d'exploitation doit donner accès aux ressources.

Mais deux processus ne peuvent pas modifier en même temps un même fichier ou écrire sur un même port.

Le système d'exploitation a pour rôle de gérer ces accès multiples par exemple en bloquant temporairement un processus en attendant que la ressource dont il a besoin soit libérée.

===== Le risque d'interblocage, deadlock =====

Deux personnes veulent manger mais il n'y a que deux baguettes. Chacun a pris une baguette et chacun attend que la 2e baguette soit libre. Alors ils meurent de faim ! Cet exemple classique est connu comme le problème du [[https://fr.wikipedia.org/wiki/D%C3%AEner_des_philosophes|dîner des philosophes]].

Dans un cas informatique, on aurait par exemple :

  * Plusieurs processus ont besoin d'utiliser un même fichier.
  * S'ils ne font que le **lire**, cela ne pose pas de difficulté. Ils peuvent **lire en même temps**.
  * S'ils doivent **modifier** le fichier, des **difficultés apparaissent** : deux processus ne peuvent pas écrire en même temps dans le même fichier.

==== Premier cas sans blocage ====

Les processus **P1** et **P2** souhaitent modifier la ressource **R**.

**P1** a pris la main en premier, l'OS bloque la ressource pour lui, **P2** attend son tour.

==== Deuxième cas avec blocage ====

  * Les processus **P1** et **P2** souhaitent modifier les ressources **R1** et **R2**.
  * **P1** a déjà pris la main sur **R1**, **P2** a déjà pris la main sur **R2**.
  * **P1** souhaite modifier **R2** mais **P2** le bloque, il faut attendre que **P2** ait fini.
  * **P2** souhaite modifier **R1** mais **P1** le bloque, il faut attendre que **P1** ait fini.

Il y a **interblocage** -- **deadlock**.

===== Résoudre le problème des interblocages =====

Prévoir les interblocages est possible ([[nsi:tds:algorithmes:algorithme_du_banquier|cf. algorithme du banquier]]) mais difficile voire irréaliste.

On peut essayer de les éviter en programmant d'une façon plus sûre, par exemple faisant en sorte que les verrous soient toujours posés dans le même ordre : Dans l'exemple, l'interblocage vient du fait que **P1** veut bloquer **R1** puis **R2** alors que **P2** bloque **R2** puis **R1**. S'ils avaient procédé dans le même ordre, il n'y aurait pas eu interblocage.

Mais en général l'OS ne cherche pas à empêcher les interblocages. Il réagit si ils arrivent : en observant le déroulement des processus, il détecte la survenue d'un interblocage, tue un processus pour débloquer la situation et relance le processus tué ensuite.