Le verrouillage est un mécanisme qui permet aux threads d'avoir un accès exclusif aux méthodes synchronisées d'une instance ; les méthodes synchronisées d'une instance verrouillée par un thread ne sont pas accessibles par les autres threads. Les autres threads doivent attendre que l'instance soit déverrouillée pour qu'ils puissent essayer à leur tour d'acquérir le verrou sur cette instance et ainsi pouvoir accéder à ses méthodes synchronisées.

Notes :

• Chaque thread peut avoir un ou plusieurs verrous.
  
  
• Une instance est verrouillée par un seul thread à la fois, et ce verrou n'affectera pas les autres instances qui peuvent être verrouillées par d'autres threads.
  
  
• Seules les méthodes synchronisées d'une instance sont impactées par le verrou acquis sur cette instance ; les autres méthodes non-synchronisées de l'instance restent accessibles pour tous les threads.
  
  
• Un thread qui obtient le verrou sur une instance peut accéder à toutes les méthodes synchronisées de cette instance.
  
  
• La synchronisation est applicable uniquement aux méthodes.
  

Une méthode est synchronisée lorsqu'elle est marquée par le mot clé synchronized.

Lorsqu'une méthode synchronisée est invoquée, le thread courant obtient un verrou sur l'instance référée par cet appel, à condition que cette instance ne soit pas déjà verrouillée par un autre thread.

Si une instance est déjà verrouillée par un thread, alors aucun autre thread ne peut avoir un verrou sur cette instance et par conséquent aucun autre thread ne peut exécuter les méthodes synchronisées de cette instance.

Chaque thread qui essaye d'acquérir le verrou sur une instance déjà verouille, sera mis en attente jusqu'à ce que l'instance soit déverrouillée.

Tant que l'exécution de la méthode synchronisée n'est pas terminée, le thread qui possède le verrou ne libère pas ce verrou et cela même si ce thread n'est plus dans l'état d'exécution (il est endormit par exemple).

class MyClassA {
    private String value;

    public synchronized void foo() { // méthode synchronisée : instance this
        setValue(Thread.currentThread().getName() + " : value");

        try {
            Thread.sleep(1000); // forcer le thread courant à s'endormir pour donner une chance à l'autre thread de s'exécuter.
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(getValue());
    }

    private String getValue() {
        return value;
    }

    private void setValue(String value) {
        this.value = value;
    }
}

public class LocksSynchronizationTest1 {
    public static void main(String[] args) {
        final MyClassA myClassA = new MyClassA();

        Runnable myRunnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " (début)");

                myClassA.foo(); // le thread courant va acquérir un verrou sur l'instance référée par la variable "myClassA"

                System.out.println(Thread.currentThread().getName() + " (fin)");
            }
        };

        Thread myThread1 = new Thread(myRunnable1, "myFirstThread");
        Thread myThread2 = new Thread(myRunnable1, "mySecondThread");

        myThread1.start();

        try {
            Thread.sleep(500); // forcer le thread "main" à s'endormir pour être sûr que le thread "myFirstThread" sera exécuté avant le thread "mySecondThread".
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        myThread2.start();
    }
}

Résultat d'exécution du code :

myFirstThread (début)
mySecondThread (début)
myFirstThread : value
myFirstThread (fin)
mySecondThread : value
mySecondThread (fin)

La différence entre la synchronisation d'une méthode et la synchronisation d'un bloc de code et que ce dernier permet de spécifier l'instance que l'on souhaite verrouiller ; alors que la synchronisation d'une méthode est toujours faite sur l'instance dont le code est en cours d'exécution.

La synchronisation d'une méthode peut toujours être remplacée par une synchronisation d'un bloc de code. Le code précédent peut être remplacé par le suivant :

class MyClassA {
    private String value;

    public void foo() {
        synchronized (this) // bloc de code synchronisé : instance this
        {
            setValue(Thread.currentThread().getName() + " : value");

            try {
                Thread.sleep(1000); // forcer le thread courant à s'endormir pour donner une chance à l'autre thread de s'exécuter.
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(getValue());
        }
    }

    private String getValue() {
        return value;
    }

    private void setValue(String value) {
        this.value = value;
    }
}

Souvent, lorsqu'on parle des instances on fait référence aux objets qui représentent des instances de la classe Object.
Mais chaque classe Java (code source) a aussi une instance de la classe Class ; cette instance est créée automatiquement par la JVM lorsqu'elle charge en mémoire le code source de cette classe en mémoire.

Une classe Java T peut avoir donc deux types d'instances en mémoire :

• Une seule instance de la classe Class qui représente une classe Java T est créée automatiquement par la JVM lorsque la classe T est utilisée pour la déclaration d'une variable.
  L'instance de la classe peut aussi être créée explicitement en utilisant la méthode forName de la classe Class (Class.forName("T")).
  Cette instance est utilisée pour accéder aux membres statiques de la classe.
  Lorsque une méthode statique est synchronisée, alors le verrouillage est appliquée sur cette instance.
  

  class T {
      static synchronized void foo() {
          // ...
      }
  
      void bar() {
          synchronized(T.class) {
              // ...
          }
      }
  }

• Une ou plusieurs instances qui représentent les objets créés à partir d'une classe Java T en utilisant l'opérateur new (new T()).
  Ces instances sont utilisées, typiquement, pour accéder aux membres non-statiques de la classe.
  Lorsque une méthode non-statique est synchronisée, alors le verrouillage est appliquée sur l'instance dont le code est en cours d'exécution.
  

  class R {
      synchronized void foo() {
          // ...
      }
  
      void bar() {
          synchronized(this) {
              // ...
          }
      }
  }

Il faut noter que le verouillage obtenu lors de l'appel d'une méthode statique synchronisée d'une classe est différent de celui obtenu lors de l'appel d'une méthode non-statique synchronisée de la même classe. Les deux verrous peuvent êtres obtenus par deux threads différents.