Threads II - Synchronized

En la entrada anterior hablabamos de los threads, y veíamos las operaciones que podíamos realizar para ordenar el tiempo de ejecución. En esta entrada vamos a tratar de la sincronización, y lo vamos a hacer con un ejemplo ficticio muy sencillito, para que los conceptos queden bien claros.

Supongamos que tenemos un bonito comercio que dispone de una página web donde se pueden hacer compras on-line. Pongamos que entre las cosas que se pueden comprar están CD´s. Nosotros, mañosos que somos, hemos hecho un programa en el que cada vez que un cliente compra un CD, este se resta a las existencias, y cuando ya no quedan, avisa de la situación:

//¡Método no sincronizado, va a fallar!
public class CompraCD{
    
   public static void main(String[] args) throws InterruptedException{
      Comprador c = new Comprador();
      Thread uno = new Thread(c);
      Thread dos = new Thread(c);
      Thread tres = new Thread(c);
      uno.setName("Elena");
      dos.setName("Luis");
      tres.setName("Alba");
      uno.start();
      dos.start();
      tres.start();
   }

     static class Comprador implements Runnable{
      int cantidad = 100;
      public void run(){
         while(cantidad > 0){
            compra();
         }
      }

      public  void compra(){
            if(cantidad>0){
           System.out.println("Comprador " + Thread.currentThread().getName() + " encargando CD");
   /*Vamos a ralentizar un poco el proceso para que se vea más claramente el output*/
               try{
                  Thread.sleep(1000);/
               }catch(InterruptedException e){
                  System.out.println("Oh, oh");
               }
               cantidad = cantidad – 1; //restamos 1 a las existencias
          System.out.println("Comprador " + Thread.currentThread().getName() + " ha comprado. Quedan " + cantidad); //Vemos quién ha comprado y la cantidad de CD´s que quedan
            }else{
               System.out.println("No hay bastantes CD´s");
            }
         
      }
   }
   
}

Ahora podéis probar a compilar y ejecutar el programa. ¿Cuál es el output?Ya os lo digo yo: un desastre. Terminaréis con números negativos en las existencias de CD´s y es posible incluso que el número de CD´s no disminuya de forma correcta, si no que haga cosas como 20-18-19. ¿Por qué?, os preguntaréis, si en el programa se especifica claramente que sólo se puede comprar mientras haya existencias. Pues porque puede haber más de una persona comprando a la vez. Suponed que sólo queda un CD y dos personas entran a la vez en la web: a las dos se les va a decir que hay existencias, y las dos van a poder realizar la compra, pero sólo vamos a tener un CD para enviar.

Vale, en la vida real el proceso no es exactamente así, pero ya dije que esto era sólo un ejemplo para que lo entendiérais. Ahora, lo que necesitamos, es una forma de impedir que dos personas compren a la vez, es decir, que mientras una persona está comprando, otra no pueda iniciar el proceso. Para eso usamos la sincronización. Bastará con añadir esta simple palabra: synchronized en el método de esta manera:

   public void synchronized compra(){}

y a partir de ahí, si un thread lo está ejecutando, los demás no lo podrán usar hasta que el otro termine. Probad ahora a compilar y ejecutar el programa y veréis como ya no vende más CD´s de los que hay.

Recordad que lo que se sincroniza son los métodos, no las clases. También puede ocurrir que tengamos un método más amplio y no necesitemos sincronizarlo todo, si no que haya partes de él que no importa si varios thread ejecutan a la vez. En ese caso, bastará con que sincronicemos el bloque que nos interesa:

public class CuentaAtras extends Thread{
    private int cuenta  = 20;
    public  void contador(){
         synchronized(this){ 
            for(int i=0; i<10; i++){
                  cuenta--;
                 System.out.println(Thread.currentThread().getName()+": "+cuenta);
            }
        }
       System.out.println("No sincronizado");
    }
   

    public void run(){ 
       contador();
    }

    public static void main (String[] args){
      CuentaAtras cd = new CuentaAtras();
      Thread t1 = new Thread(cd);
      Thread t2 = new Thread(cd);
      t1.start();
      t2.start();
   }
}

La salida de este código será la siguiente:

Thread-1: 19

Thread-1: 18

Thread-1: 17

Thread-1: 16

Thread-1: 15

Thread-1: 14

Thread-1: 13

Thread-1: 12

Thread-1: 11

Thread-1: 10

Thread-2: 9

Thread-2: 8

Thread-2: 7

Thread-2: 6

Thread-2: 5

Thread-2: 4

Thread-2: 3

Thread-2: 2

Thread-2: 1

Thread-2: 0

No sincronizado

No sincronizado //Estas dos últimas líneas pueden variar

Vemos que el primer thread se ejecuta completamente antes de que empiece el segundo, y como cuando empieza el segundo la cuenta atrás ha ido desde el número 19 hasta el 10, él empieza en el 9.

La sincronización es como una llave que permite entrar a un thread en un bloque de código, y mientras ese thread tiene la llave, ningún otro thread puede entrar en él. De hecho, todos los objetos en java tienen un lock o cerradura, también llamado monitor. Pero eso es otra historia.

Esperamos que estas nociones básicas sobre threads y sincronización os hayan sido útiles.

Nos gustaría agradecer especialmente a los amables habitantes de JavaRanch por su ayuda en la elaboración de esta entrada.