On utilise une seule variable booléenne M telle que M = vrai si un des processus se trouve dans sa section critique, faux sinon. Ecrire le programme Vérifier que l'exclusion mutuelle ne peut être ainsi programmée. On suppose qu'on attribue à P0 et P1, les identifiants 0 et 1

/*déclarations et initialisation des variables globales*/
int M = 0 ;//M est a faux
/* etat d'occupation de la ressource*/
Tâche P0
While (1) {
       /*entree_SC */
       while (M );/* attente active*/
       M=1;//M est a vrai
       Section_critique();
       /*sortie_SC*/
       M=0;
       Section_non_critique() ;
}
Tâche P1
While (1) {
       /*entree_SC */
       while (M );/* attente active*/
       M=1;
       Section_critique();
       /*sortie_SC*/
       M=0;
       Section_non_critique() ;
}

Une exécution « entrelacée » de l'entrée en Section critique, par les deux tâches entraîne le non-respect de l'exclusion mutuelle, entree_SC n'est pas atomique

/*déclarations et initialisation des variables globales*/
int T = 0 ;
/* T vaut 0 ou 1 tâche autorisée à entrer en section critique*/
Tâche P0
While (1) {
       /*entree_SC */
       while (T==1 );/* attente active*/
       Section_critique();
       /*sortie_SC*/
       T=1;
       Section_non_critique() ;
}
Tâche P1
While (1) {
       /*entree_SC */
       while (T==0 );/* attente active*/
       Section_critique();
       /*sortie_SC*/
       T=0 ;
       Section_non_critique() ;
}

Cette solution règle le problème de l'exclusion mutuelle, une seule tâche peut entrer en SC(valeur de T). C'est un fonctionnement à l'alternat donc si un processus tombe en panne hors section critique, l'autre processus sera bloqué. La condition c) n'est pas respectée.

/*déclarations et initialisation des variables globales*/
int C[2]={0,0};
Tâche P0
While (1) {
      /*entree_SC */
      while (C[1]);/* attente active*/
      C[0]=1 ;
      Section_critique();
      /*sortie_SC*/
      C[0]=0;
      Section_non_critique() ;
}
Tâche P1
While (1) {
  /*entree_SC */
  while (C[0]);/* attente active*/
  C[1]=1 ;
  Section_critique();
  /*sortie_SC*/
  C[1]=0;
  Section_non_critique() ;
}

L'exclusion mutuelle n'est pas garantie, chaque tâche peut trouver la variable C de l'autre tâche à faux et décider son entrée en SC Une autre solution pourrait être que chaque processus positionne sa variable à true, puis teste la variable de l'autre processus, dans ce cas on risque un blocage mutuel indéfini.

/*déclarations et initialisation des variables globales*/
int C[2]={0,0} ;
int T=0
Tâche P0
while (1) {
      /*entree_SC */
      C[0]=1 ;
      while (C[1]) { /* P1 est en SC ou a demande a entrer en SC*/
            while (T==1) C[0]=0 ;/*P1 est prioritaire, retrait de P0*/
            C[0]=1 ;/*T=0 P0 recandidate*/
      }
      Section_critique();
      /*sortie_SC*/
      C[0]=0;
      T=1 ;
      Section_non_critique() ;
}
Tâche P1
While (1) {
      /*entree_SC */
  C[1]=1 ;
  while (C[0]) { /* P0 est en SC ou a demande a entrer en SC*/
        while (T==0) C[1]=0 ;/*P0 est prioritaire, retrait de P1*/
        C[1]=1 ;/*T=1 P1 recandidate*/
  }
  Section_critique();
  /*sortie_SC*/
  C[1]=0;
  T=0 ;
  Section_non_critique() ;
}