Les méthodes de classe peuvent étre synchronisées, à l'instar des méthodes d'instance. Toutefois, le verrou de classe utilisé par défaut est un objet Class qui représente la classe courante. Pour les méthodes d'instances, il s'agissait de l'objet courant this qui faisait office de verrou.

public static synchronized void uneMethodeDeClasse(){
  //...
}

En ce qui concerne les blocs de code synchronisés dans des méthodes de classe, le verrou dépend des variables sensibles à sécuriser.

public static boolean sauvegarder(DocumentXML document){
public static boolean sauvegarder(Document document) {
    if(document ==  null || repertoire == null) return false;
    try {
        DOMImplementationLS implLS = null;
        if(document.getImplementation().hasFeature("LS", "3.0")) {
            implLS = (DOMImplementationLS)
                                      document.getImplementation();
        }
        else { 
            DOMImplementationRegistry enregistreur = 
                                          DOMImplementationRegistry.newInstance();
            implLS = (DOMImplementationLS)
                                enregistreur.getDOMImplementation("LS 3.0");
        }
        if(implLS == null){
            System.out.println(
                "Votre implémentation ne supporte "
              + "pas l'API DOM Load and Save !");
             return false;
         }
        LSSerializer serialiseur = implLS.createLSSerializer();
        LSOutput sortie = implLS.createLSOutput();
        sortie.setEncoding("ISO-8859-1");
        synchronized(document){
            File fichier = new File(
                    document.getDocumentElement().getNodeName() + ".xml");
            FileOutputStream fluxSortie = new FileOutputStream(fichier);
            sortie.setSystemId(fichier.toString());
            sortie.setByteStream(fluxSortie);
            serialiseur.write(document, sortie);
            fluxSortie.flush();
            fluxSortie.close();
        }
        return true;
    }
    catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}

L'imbrication des zones synchronisées dans des méthodes de classe peut entraîner une utilisation de verrous de classe et d'objet. S'il est nécessaire de protéger un objet particulier dans une section critique de méthode de classe synchronisée, alors il est possible de synchroniser l'exécution sur cet objet. Ainsi, le thread devra acquérir le verrou de classe en entrant dans la méthode, puis devra acquérir le verrou d'objet document pour accèder au bloc de code synchronisé.

public static synchronized boolean sauvegarder(Document document) {
    //...
    synchronized(document){
        File fichier = new File(
                document.getDocumentElement().getNodeName() + ".xml");
        FileOutputStream fluxSortie = new FileOutputStream(fichier);
        sortie.setSystemId(fichier.toString());
        sortie.setByteStream(fluxSortie);
        serialiseur.write(document, sortie);
        fluxSortie.flush();
        fluxSortie.close();
    }
    return true;
    //...
}

A l'inverse, si une méthode d'instance tente de manipuler des champs statiques sensibles, il faut englober ces dernières dans un bloc de code synchronisé, lequel peut prendre comme verrou soit un objet statique, soit un objet Class de la classe à laquelle appartiennent ces champs.

public class UneClasse {
    public static int champSensible = 0;
    public synchronized uneMethode(){
        synchronized(Class.forName("UneClasse")){
        // ou synchronized(this.getClass()){
        // ou synchronized(UneClasse.class){
            champSensible++;
        }
    }
}

La méthode getClass() ou le champ class retourne la classe d'exécution d'un objet. L'objet Class obtenu est le verrou de classe exploité par les méthodes statiques synchronisées de la classe courante. Tandis que celui fourni par le chargeur de classe constitue un objet Class qui n'est pas lié à l'instance de la classe en cours d'exécution.

Un objet statique commun à toutes les instances de la classe courante, peut être utiliser comme verrou.

public class UneClasse {
    private static Object verrou = new Object();
    public static int champSensible = 0;
    public synchronized uneMethode(){
        synchronized(verrou){
            champSensible++;
        }
    }
}