Métodos y bloques sincronizados

Bloques sincronizados en métodos de instancia

No es necesario que sincronicemos un método completo. A veces es preferible sincronizar solo una parte de uno. Los bloques sincronizados de Java dentro de los métodos hacen esto posible.

El siguiente es un bloque de código Java sincronizado dentro de un método de Java no sincronizado:

public void sumar(int valor) {
    synchronized(this) {
        this.cuenta += valor;
    }
}

Este ejemplo utiliza la construcción de bloque sincronizado de Java para marcar un bloque de código como sincronizado. Este código ahora se ejecutará como si fuera un método sincronizado.

Observemos cómo la construcción del bloque sincronizado de Java toma un objeto entre paréntesis. En el ejemplo se usa “this”, que es la instancia en la que se llama al método sumar. El objeto tomado entre paréntesis por la construcción sincronizada se llama objeto monitor. Se dice que el código está sincronizado en el objeto monitor. Un método de instancia sincronizado utiliza el objeto al que pertenece como objeto monitor.

Solo un hilo puede ejecutarse dentro de un bloque de código Java sincronizado en el mismo objeto monitor.

Los siguientes dos ejemplos están ambos sincronizados en la instancia en la que se llaman. Por lo tanto, son equivalentes con respecto a la sincronización:

public class MiClase {
    public synchronized void log1(String msg1, String msg2) {
        log.escribirLinea(msg1);
        log.escribirLinea(msg2);
    }

    public void log2(String msg1, String msg2) {
        synchronized(this) {
            log.escribirLinea(msg1);
            log.escribirLinea(msg2);
        }
    }
}

Así, solo un único hilo puede ejecutarse dentro de cualquiera de los dos bloques sincronizados en este ejemplo.

Si el segundo bloque sincronizado hubiera estado sincronizado en un objeto diferente a “this”, entonces un hilo a la vez habría podido ejecutarse dentro de cada método.

Ejemplo de Sincronización en Java

Este ejemplo inicia 2 hilos y hace que ambos llamen al método sumar en la misma instancia de Contador. Solo un hilo a la vez podrá llamar al método sumar en la misma instancia, porque el método está sincronizado en la instancia a la que pertenece.

public class Ejemplo {
    public static void main(String[] args) {
        Contador contador = new Contador();
        Thread hiloA = new HiloContador(contador);
        Thread hiloB = new HiloContador(contador);

        hiloA.start();
        hiloB.start();
    }
}

Estas son las dos clases utilizadas en el ejemplo anterior, Contador e HiloContador.

public class Contador {
    long cuenta = 0;

    public synchronized void sumar(long valor) {
        this.cuenta += valor;
    }
}

public class HiloContador extends Thread {
    protected Contador contador = null;

    public HiloContador(Contador contador) {
        this.contador = contador;
    }

    public void run() {
        for(int i = 0; i < 10; i++) {
            contador.sumar(i);
        }
    }
}

Se crean dos hilos. La misma instancia de Contador se pasa a ambos en su constructor. El método Contador.sumar() está sincronizado en la instancia, porque el método sumar() es un método de instancia y está marcado como sincronizado. Por lo tanto, solo uno de los hilos puede llamar al método sumar() a la vez. El otro hilo esperará hasta que el primer hilo salga del método sumar(), antes de poder ejecutar el método él mismo.

Si los dos hilos hubieran hecho referencia a dos instancias separadas de Contador, no habría habido problemas para llamar a los métodos sumar() simultáneamente. Las llamadas habrían sido a diferentes objetos, por lo que los métodos llamados también estarían sincronizados en diferentes objetos (el objeto que posee el método). Por lo tanto, las llamadas no se bloquearían. Esto se puede ver como sigue:

public class Ejemplo {
    public static void main(String[] args) {
        Contador contadorA = new Contador();
        Contador contadorB = new Contador();
        Thread hiloA = new HiloContador(contadorA);
        Thread hiloB = new HiloContador(contadorB);

        hiloA.start();
        hiloB.start();
    }
}

Observemos cómo los dos hilos, hiloA e hiloB, ya no hacen referencia a la misma instancia de contador. El método sumar de contadorA y contadorB está sincronizado en sus dos instancias propias. Llamar a sumar() en contadorA no bloqueará una llamada a sumar() en contadorB.