Para comprender mejor los bloques de código sincronizado, primero analizaremos dos conjuntos de código funcionalmente similares sin sincronización y sus resultados de ejecución en diferentes estados. Veamos el primer conjunto:

package com.ejemplos.sincronizacion;

public class DemoSincronizacion {
   public static void main(String[] args) {
       new Thread() {
           public void run() {
               while (true) {
                   System.out.println("Código sincronizado");
               }
           };
       }.start();
       new Thread() {
           public void run() {
               while (true) {
                   System.out.println("SynchronizedCode");
               }
           };
       }.start();
   }
}

Resultado de ejecución del primer conjunto:

SynchronizedCode
SynchronizedCode
SynchronizedCode
SynchronizedCode
Código sincronizado
Código sincronizado
Código sincronizado
Código sincronizado

Ahora veamos el segundo conjunto de código:

package com.ejemplos.sincronizacion;

public class DemoSincronizacion {
   public static void main(String[] args) {
       new Thread() {
           public void run() {
               while (true) {
                   System.out.print("Sincro");
                   System.out.println("nizado");
               }
           };
       }.start();
       new Thread() {
           public void run() {
               while (true) {
                   System.out.print("Sync");
                   System.out.println("hronized");
               }
           };
       }.start();
   }
}

Resultado de ejecución del segundo conjunto:

Sincronizado
Sincronizado
Sincronizado
Syncnizado
Syncronized
Syncronized
Syncronized
Syncronized

Claramente, en el segundo conjunto de código, las salidas de impresión del mismo hilo no se ejecutaron simultáneamente. Esto se debe a la aleatoriedad del cambio de CPU entre diferentes hilos. La salida "Syncnizado" en el segundo conjunto de código ocurrió porque cuando la CPU cambió al hilo 1, imprimió "Sincro", pero cuando el programa estaba a punto de imprimir "nizado", la CPU cambió al hilo 2 e imprimió "hronized", y luego el hilo 2 continuó utilizando los recursos de la CPU para imprimir hasta que la CPU cambió nuevamente al hilo 1. Esta es la razón por la que cuando un programa contiene múltiples hilos, el código dentro del mismo hilo no puede ejecutarse simultáneamente. Entonces, ¿cómo podemos evitar que esto suceda? Utilizando bloques de código sincronizado. A continuación, veamos los resultados de ejecución de un programa que utiliza bloques de código sincronizado:

package com.ejemplos.sincronizacion;

public class DemoSincronizacion {
   public static void main(String[] args) {
       /************ Crear objeto de bloqueo ************/
       final Object cerrojo = new Object();
       /************ Iniciar hilo uno ************/
       new Thread() {
           public void run() {
               while (true) {
                   synchronized (cerrojo) {
                       System.out.print("Sincro");
                       System.out.println("nizado");
                   }
               }
           };
       }.start();
       /************ Iniciar hilo dos ************/
       new Thread() {
           public void run() {
               while (true) {
                   synchronized (cerrojo) {
                       System.out.print("Sync");
                       System.out.println("hronized");
                   }
               }
           };
       }.start();
   }
}

Al ejecutar el código anterior,我们发现 que el resultado de ejecución es similar al del primer conjunto. Esto se debe a que los bloques de código sincronizado con el mismo objeto de bloqueo tienen atomicidad. Durante su ejecución, continúan teniendo los recursos de la CPU hasta que el bloque de código sincronizado se completa por completo. O bien, continúan manteniendo los recursos de la CPU, o la CPU cambia a otro hilo. Esto garantiza que cuando se ejecuta un conjunto de código, ningún otro hilo pueda insertarse y ejecutarse.