Algunos ejemplos de algoritmos cl�sicos de exclusi�n mutua son:

• El algoritmo de Dekker.
• El algoritmo de Peterson.
• El algoritmo de la panader�a de Lamport

El algoritmo de Dekker es un algoritmo para exclusi�n mutua, que permite a dos procesos o hilos de ejecuci�n compartir un recurso sin conflictos. Fue uno de los primeros algoritmos de exclusi�n mutua inventados, implementado por Edsger Dijkstra.
Si ambos procesos intentan acceder a la secci�n cr�tica simult�neamente, el algoritmo elige un proceso seg�n una variable turno. Si el otro proceso est� ejecutando en su secci�n cr�tica, deber� esperar su finalizaci�n.
Existen 5 versiones del algoritmo Dekker, teniendo ciertos fallos los primeros cuatro. Siendo la versi�n 5 la que trabaja mas eficientemente.

Versi�n 1: Alternancia Estricta.

   Garantiza la exclusi�n mutua, pero su desventaja es que acopla los procesos fuertemente.

Versi�n 2: Problema interbloqueo.

   No existe la alternancia, aunque ambos procesos pueden alcanzar sus secciones cr�ticas simult�neamente.

Versi�n 3: Colisi�n regi�n critica no garantiza la exclusi�n mutua.

   Se evita que ambos procesos accedan simult�neamente, y en caso de que lleguen a sus secciones criticas al mismo tiempo se

   Bloquean mutuamente, creando una espera infinita.

Versi�n 4: Postergaci�n indefinida.

   Los procesos hacen algo pero no llegan a hacer algo �til, siguen esperando algo que nunca ocurrir�.

shared int cierto = 1;

/* Definici�n de variables compartidas */ 

shared int bandera[2] = {0,0};   

shared int turno      = 0; 

while (cierto)

{

   bandera[proc_id] = cierto;

   while (bandera[1-proc_id] == cierto)

   {

      if (turno == 1-proc_id)

      {

         bandera[proc_id] = 0;

         while (turno == (1-proc_id))  /* espera a que sea su turno de intentar */;

         bandera[proc_id] = 1;

      }

   /* Secci�n cr�tica */

   turno = 1-proc_id;                 /* es el turno del otro proceso */

   bandera[proc_id] = 0;

   /* Secci�n no cr�tica */

   }

}

El algoritmo de Peterson es un algoritmo para exclusi�n mutua, que permite a dos o m�s procesos o hilos de ejecuci�n compartir un recurso sin conflictos, utilizando s�lo memoria compartida para la comunicaci�n.

bandera[0] = 0

 bandera[1] = 0

 turno      = 0 

 p0: bandera[0] = 1                            p1: bandera[1] = 1

     turno = 0                                 turno = 1

     while( bandera[1] && turno == 0 );        while( bandera[0] && turno == 1 );

               //no hace nada. espera.                               //no hace nada. espera. 

     // secci�n cr�tica                        // secci�n cr�tica

     ...                                       ...

     // fin de la secci�n cr�tica              // fin de la secci�n cr�tica

     bandera[0] = 0                            bandera[1] = 0

El algoritmo de la panader�a de Lamport es un algoritmo de computaci�n creado por el cient�fico en computaci�n Dr Leslie Lamport, para implementar la exclusi�n mutua de N procesos o hilos de ejecuci�n.
El algoritmo de la panader�a toma su nombre de la costumbre de las panader�as y tiendas en general, donde las personas al entrar al local obtienen un n�mero de turno (�nico) y lo utilizan para el dependiente les vaya atendiendo en orden de llegada. El cliente obtiene su n�mero de turno usando una cinta de papel que ofrece boletos con n�meros consecutivos.
El dependiente s�lo puede atender a una persona al mismo tiempo, lo que concuerda con el uso de un recurso de forma exclusiva: el recurso es el dependiente y la secci�n cr�tica de un cliente es lo que realiza mientras es atendido.
El sistema mantiene un n�mero (variable global) que refleja el n�mero de turno del cliente que se est� atendiendo en el instante actual. Los clientes deben esperar en una cola hasta que llega su turno. Una vez que se acaba con un cliente, la variable global se incrementa en uno y el cliente que tenga un boleto con ese n�mero pasa a ser atendido. Cuando termina una compra, el cliente se desprende de su boleto y se dedica a realizar cualquier otra actividad libremente (guardar el dinero en la billetera, retirarse, etc.), ya que no se encuentra m�s en su secci�n cr�tica. Si m�s tarde quiere volver a comprar, tendr� que obtener un nuevo n�mero.
El modelo algor�tmico que se propone, cada cliente es un hilo, identificado con un n�mero �nico i. Los hilos se deben coordinar para decidir en cada momento qu� hilo tiene derecho a ejecutar su c�digo de secci�n cr�tica.
En la vida real, el sistema de los boletos funciona perfectamente, pero en un sistema inform�tico la obtenci�n del boleto es problem�tica: varios hilos pueden obtener el mismo n�mero de turno. En el algoritmo de Lamport se permite que varios hilos obtengan el mismo n�mero. En este caso, se aplica un algoritmo de desempate, que garantiza que s�lo un hilo entra en secci�n cr�tica. El desempate se realiza as�: si dos o m�s hilos tienen el mismo n�mero de turno, tiene m�s prioridad el hilo que tenga el identificador con un n�mero m�s bajo. Como no puede haber dos hilos con el mismo identificador, nunca se da el caso de que dos hilos eval�en al mismo tiempo que tienen derecho a ejecutar su secci�n cr�tica.
Cuando un hilo quiere entrar en su secci�n cr�tica, primero obtiene su n�mero de turno, que calcula como el m�ximo de los turnos de los otros hilos, m�s uno. (Si varios hilos realizan el c�lculo al mismo tiempo, puede ocurrir que dos o m�s hilos obtengan el mismo turno).
Antes de entrar en secci�n cr�tica, el hilo debe asegurarse de que tiene el n�mero de turno m�s bajo. En caso de empate, decidir� el identificador de hilo m�s bajo.
Cuando el hilo abandona la secci�n cr�tica, pone su n�mero de turno a un valor especial que indique su no intenci�n de entrar en secci�n cr�tica (en este algoritmo, se usa el valor cero).

Pseudoc�digo

N es el n�mero de hilos que hay en el sistema.
Para conocer los n�meros de turno se utiliza un vector de enteros. n�mero[i] es el turno correspondiente al hilo i. Si n�mero[i] = 0 significa que el hilo i no est� interesado en entrar en secci�n cr�tica.

/* Variables globales */

  N�mero: vector [1..N] de enteros  = {todos a 0};

  Eligiendo: vector [1..N] de booleanos = {todos a falso};

  /* C�digo del hilo i */

  Hilo(i) {

      loop {

          /* Calcula el n�mero de turno */

          Eligiendo[i] = cierto;

          N�mero[i] = 1 + max(N�mero[1], ..., N�mero[N]);

          Eligiendo[i] = falso;

          /* Compara con todos los hilos */

          for j in 1..N {                     

               /* Si el hilo j est� calculando su n�mero, espera a que termine */

               while ( Eligiendo[j] ) { /* nada */ }       

               /* Si el hilo j tiene m�s prioridad, espera a que ponga su n�mero a cero */

               /* j tiene m�s prioridad si su n�mero de turno es m�s bajo que el de i,  */

               /*  o bien si es el mismo n�mero y adem�s j es menor que i               */

               while ( (N�mero[j] != 0) && ((N�mero[j], j) < (N�mero[i], i)) ) { /* nada */ }  

          }

          /* Secci�n cr�tica */

          ...

          /* Fin de secci�n cr�tica */

          N�mero[i] = 0;

          /* C�digo restante */

      }

  }