Est-il un avantage à utiliser une Méthode Synchronisée au lieu d'un Bloc Synchronisé?

la seule différence réelle est qu'un bloc synchronisé peut choisir sur quel objet il se synchronise. Une méthode synchronisée ne peut utiliser que 'this' (ou l'instance de classe correspondante pour une méthode de classe synchronisée). Par exemple, ils sont sémantiquement équivalents:

synchronized void foo() {
  ...
}

void foo() {
    synchronized (this) {
      ...
    }
}

ce dernier est plus flexible puisqu'il peut rivaliser pour la serrure associée de n'importe quel objet, souvent une variable membre. C'est aussi plus granulaire parce que vous pouvez avoir du code concurrent exécuté avant et après le bloc mais toujours dans la méthode. Bien sûr, vous pouvez tout aussi facilement utiliser une méthode synchronisée en refactorisant le code concurrent en méthodes non synchronisées séparées. Utilisez celui qui rend le code plus compréhensible.

Méthode Synchronisée

Pour:

• votre IDE peut indiquer les méthodes synchronisées.
• la syntaxe est plus compacte.
• Forces pour diviser les blocs synchronisés pour séparer les méthodes.

Inconvénients:

• synchronise à ceci et permet ainsi aux étrangers de se synchroniser à lui aussi.
• il est plus difficile de déplacer le code en dehors du bloc synchronisé.

bloc synchronisé

Pour:

• permet d'utiliser une variable privée pour la serrure et donc forcer la serrure à rester à l'intérieur de la classe.
• blocs synchronisés peuvent être trouvés en recherchant des références à la variable.

Inconvénients:

• la syntaxe est plus compliquée et donc rend le code plus difficile à lire.

personnellement, je préfère utiliser des méthodes synchronisées avec des classes axées uniquement sur la chose à synchroniser. Une telle classe devrait être aussi petite que possible et donc il devrait être facile de revoir la synchronisation. Les autres ne devraient pas avoir besoin de se soucier de la synchronisation.

La différence principale est que si vous utilisez un bloc synchronisé vous pouvez verrouiller sur un objet autre que ce qui permet d'être beaucoup plus souple.

supposons que vous avez une file d'attente de messages et plusieurs producteurs de messages et consommateurs. Nous ne voulons pas que les producteurs interfèrent les uns avec les autres, mais les consommateurs devraient pouvoir récupérer les messages sans avoir à attendre les producteurs. Donc nous créons juste un objet

Object writeLock = new Object();

et à partir de Maintenant chaque fois qu'un producteur veut ajouter un nouveau message, nous nous en tenons à cela:

synchronized(writeLock){
  // do something
}

donc les consommateurs peuvent toujours lire, et les producteurs seront verrouillés.

méthode synchronisée

les méthodes synchronisées ont deux effets.

Tout d'abord, lorsqu'un thread exécute une méthode synchronisée pour un objet, tous les autres threads qui invoquent des méthodes synchronisées pour le même bloc d'objet (suspendre l'exécution) jusqu'à ce que le premier thread soit fait avec l'objet.

Deuxièmement, lorsqu'une méthode synchronisée sort, elle établit automatiquement une relation happens-before toutes les invocation d'une méthode synchronisée pour le même objet. Cela garantit que les modifications de l'état de l'objet sont visibles par tous les threads.

notez que les constructeurs ne peuvent pas être synchronisés - utiliser le mot-clé synchronisé avec un constructeur est une erreur de syntaxe. Synchroniser des constructeurs n'a pas de sens, car seul le thread qui crée un objet doit y avoir accès pendant sa construction.

Déclaration Synchronisée

Contrairement aux méthodes synchronisées, les instructions synchronisées doivent spécifier l'objet qui fournit le verrouillage intrinsèque: le plus souvent j'utilise ceci pour synchroniser l'accès à une liste ou une carte mais je ne veux pas bloquer l'accès à toutes les méthodes de l'objet.

Q: serrures intrinsèques et synchronisation La synchronisation est construite autour d'une entité interne connue sous le nom de serrure intrinsèque ou serrure de moniteur. (La spécification API fait souvent référence cette entité simplement comme un "moniteur.") Les serrures intrinsèques jouent un rôle dans les deux aspects de la synchronisation: imposer l'accès exclusif à l'état d'un objet et établir des happens-avant les relations qui sont essentielles à la visibilité.

tout objet possède une serrure intrinsèque qui lui est associée. Par convention, un thread qui a besoin d'un accès exclusif et cohérent aux champs d'un objet doit acquérir la serrure intrinsèque de l'objet avant d'y accéder, puis libérer le verrouillage intrinsèque quand il est fait avec eux. Un fil est dit posséder la serrure intrinsèque entre le moment où il a acquis la serrure et libéré la serrure. Tant qu'un thread possède une serrure intrinsèque, aucun autre thread ne peut acquérir la même serrure. L'autre fil se bloquer lorsqu'il tente d'acquérir le verrou.

package test;

public class SynchTest implements Runnable {  
    private int c = 0;

    public static void main(String[] args) {
        new SynchTest().test();
    }

    public void test() {
        // Create the object with the run() method
        Runnable runnable = new SynchTest();
        Runnable runnable2 = new SynchTest();
        // Create the thread supplying it with the runnable object
        Thread thread = new Thread(runnable,"thread-1");
        Thread thread2 = new Thread(runnable,"thread-2");
//      Here the key point is passing same object, if you pass runnable2 for thread2,
//      then its not applicable for synchronization test and that wont give expected
//      output Synchronization method means "it is not possible for two invocations
//      of synchronized methods on the same object to interleave"

        // Start the thread
        thread.start();
        thread2.start();
    }

    public synchronized  void increment() {
        System.out.println("Begin thread " + Thread.currentThread().getName());
        System.out.println(this.hashCode() + "Value of C = " + c);
//      If we uncomment this for synchronized block, then the result would be different
//      synchronized(this) {
            for (int i = 0; i < 9999999; i++) {
                c += i;
            }
//      }
        System.out.println("End thread " + Thread.currentThread().getName());
    }

//    public synchronized void decrement() {
//        System.out.println("Decrement " + Thread.currentThread().getName());
//    }

    public int value() {
        return c;
    }

    @Override
    public void run() {
        this.increment();
    }
}

contre-vérifier différentes sorties avec méthode synchronisée, bloc et sans synchronisation.

Note: static méthodes synchronisées et blocs de travail sur l'objet de classe.

public class MyClass {
   // locks MyClass.class
   public static synchronized void foo() {
// do something
   }

   // similar
   public static void foo() {
      synchronized(MyClass.class) {
// do something
      }
   }
}

quand le compilateur java convertit votre code source en code octet, il gère les méthodes synchronisées et les blocs synchronisés très différemment.

lorsque la JVM exécute une méthode synchronisée, le thread d'exécution identifie que la structure method_info de la méthode a le drapeau ACC_SYNCHRONISÉ, puis il acquiert automatiquement la serrure de l'objet, appelle la méthode, et libère la serrure. Si une exception se produit, le thread déclenche automatiquement la serrure.

synchroniser un bloc de méthode, d'autre part, contourne le support intégré de la JVM pour acquérir la manipulation de verrouillage et d'exception d'un objet et exige que la fonctionnalité soit explicitement écrite en code octet. Si vous lisez le code d'octets pour une méthode avec un bloc synchronisé, vous verrez plus d'une douzaine d'opérations supplémentaires pour gérer cette fonctionnalité.

cela montre des appels pour générer à la fois une méthode synchronisée et un bloc synchronisé:

public class SynchronizationExample {
    private int i;

    public synchronized int synchronizedMethodGet() {
        return i;
    }

    public int synchronizedBlockGet() {
        synchronized( this ) {
            return i;
        }
    }
}

la méthode synchronizedMethodGet() génère le code byte suivant:

0:  aload_0
1:  getfield
2:  nop
3:  iconst_m1
4:  ireturn

et voici le code d'octet de la méthode synchronizedBlockGet() :

0:  aload_0
1:  dup
2:  astore_1
3:  monitorenter
4:  aload_0
5:  getfield
6:  nop
7:  iconst_m1
8:  aload_1
9:  monitorexit
10: ireturn
11: astore_2
12: aload_1
13: monitorexit
14: aload_2
15: athrow

une différence importante entre la méthode synchronisée et le bloc est que le bloc synchronisé réduit généralement la portée de l'écluse. Comme la portée de la serrure est inversement proportionnelle à la performance, il est toujours préférable de verrouiller seulement la section critique du code. Un des meilleurs exemples de l'utilisation de bloc synchronisé est double contrôle de verrouillage dans le modèle Singleton où au lieu de la méthode de verrouillage entier getInstance() nous ne verrouiller la section critique du code qui est utilisé pour créer l'instance Singleton. Cela améliore considérablement les performances car le verrouillage n'est nécessaire qu'une ou deux fois.

tout en utilisant des méthodes synchronisées, vous aurez besoin de prendre des précautions supplémentaires si vous mélangez static synchronized et non-static synchronisé méthodes.

le Plus souvent je l'utilise pour synchroniser l'accès à une liste ou sur la carte mais je ne veux pas bloquer l'accès à toutes les méthodes de l'objet.

dans le code suivant, un thread modifiant la liste ne sera pas bloqué en attendant un thread modifiant la carte. Si les méthodes étaient synchronisées sur l'objet alors chaque méthode devrait attendre même si les modifications qu'ils font ne serait pas en conflit.

private List<Foo> myList = new ArrayList<Foo>();
private Map<String,Bar) myMap = new HashMap<String,Bar>();

public void put( String s, Bar b ) {
  synchronized( myMap ) {
    myMap.put( s,b );
    // then some thing that may take a while like a database access or RPC or notifying listeners
  }
}

public void hasKey( String s, ) {
  synchronized( myMap ) {
    myMap.hasKey( s );
  }
}

public void add( Foo f ) {
  synchronized( myList ) {
    myList.add( f );
// then some thing that may take a while like a database access or RPC or notifying listeners
  }
}

public Thing getMedianFoo() {
  Foo med = null;
  synchronized( myList ) {
    Collections.sort(myList);
    med = myList.get(myList.size()/2); 
  }
  return med;
}

avec des blocs synchronisés, vous pouvez avoir plusieurs synchroniseurs, de sorte que plusieurs choses simultanées mais non-conflictuelles peuvent continuer en même temps.

peuvent être vérifiées à l'aide de l'API de réflexion. Cela peut être utile pour tester certains contrats, tels que toutes les méthodes dans le modèle sont synchronisées .

l'extrait suivant imprime toutes les méthodes synchronisées de Hashtable:

for (Method m : Hashtable.class.getMethods()) {
        if (Modifier.isSynchronized(m.getModifiers())) {
            System.out.println(m);
        }
}

Note importante sur l'utilisation du bloc synchronisé: attention à ce que vous utilisez comme objet lock!

le code extrait de user2277816 ci-dessus illustre ce point en ce qu'une référence à une chaîne littérale est utilisée comme objet de verrouillage. Réalisez que la littérature des cordes est automatiquement internée en Java et vous devriez commencer à voir le problème: chaque morceau de code qui se synchronise sur le "lock" littéral, partage le même lock! Cela peut facilement conduire à des blocages avec complètement des morceaux de code sans rapport.

ce n'est pas seulement des objets String que vous devez faire attention. Les primitives en boîte sont également un danger, puisque l'auto-oxydation et la valeur des méthodes peuvent réutiliser les mêmes objets, selon la valeur.

Pour plus d'informations, voir: https://www.securecoding.cert.org/confluence/display/java/LCK01-J.+Do+not+synchronize+on+objects+that+may+be+réutilisé

souvent utiliser une serrure sur un niveau de méthode est trop rude. Pourquoi verrouiller un morceau de code qui n'accède à aucune ressource partagée en verrouillant une méthode entière. Puisque chaque objet a une serrure, vous pouvez créer des objets factices pour implémenter la synchronisation de niveau de bloc. le niveau du bloc est plus efficace parce qu'il ne bloque pas l'ensemble de la méthode.

voici quelques exemples

Niveau De La Méthode

class MethodLevel {

  //shared among threads
SharedResource x, y ;

public void synchronized method1() {
   //multiple threads can't access
}
public void synchronized method2() {
  //multiple threads can't access
}

 public void method3() {
  //not synchronized
  //multiple threads can access
 }
}

"151990920 De Niveau De Bloc

class BlockLevel {
  //shared among threads
  SharedResource x, y ;

  //dummy objects for locking
  Object xLock = new Object();
  Object yLock = new Object();

    public void method1() {
     synchronized(xLock){
    //access x here. thread safe
    }

    //do something here but don't use SharedResource x, y
    // because will not be thread-safe
     synchronized(xLock) {
       synchronized(yLock) {
      //access x,y here. thread safe
      }
     }

     //do something here but don't use SharedResource x, y
     //because will not be thread-safe
    }//end of method1
 }

[Modifier]

Pour Collection comme Vector et Hashtable ils sont synchronisés lorsque ArrayList ou HashMap ne le sont pas et vous avez besoin de définir synchronisé mot-clé ou d'appeler des Collections méthode synchronisée:

Map myMap = Collections.synchronizedMap (myMap); // single lock for the entire map
List myList = Collections.synchronizedList (myList); // single lock for the entire list

méthode synchronisée est utilisé pour verrouiller tous les objets Le bloc synchronisé est utilisé pour verrouiller un objet spécifique

la seule différence: les blocs synchronisés permettent le verrouillage granulaire contrairement à la méthode synchronisée

fondamentalement synchronized bloc ou des méthodes ont été utilisés pour écrire le code de thread sûr en évitant les erreurs d'incohérence de mémoire.

cette question est très ancienne et beaucoup de choses ont changé au cours des 7 dernières années. De nouveaux concepts de programmation ont été introduits pour la sécurité des fils.

vous pouvez obtenir la sécurité du thread en utilisant l'API de concurrence avancée au lieu de synchronied blocs. Cette documentation page fournit de bonnes constructions de programmation pour atteindre la sécurité de filetage.

Lock Objects prise en charge des idiomes de verrouillage qui simplifient de nombreuses applications concurrentes.

exécuteurs testamentaires définit une API de haut niveau pour le lancement et la gestion des threads. Implémentations exécuteurs fournies par java.util.gestion simultanée du pool de threads approprié pour les applications à grande échelle.

Concurrent Collections rendre plus facile à gérer de grands ensembles de données, et peut réduire considérablement la nécessité pour la synchronisation.

Variables Atomiques ont des fonctionnalités qui minimisent la synchronisation et aider à éviter les erreurs de cohérence de la mémoire.

au Royaume-Uni (dans JDK 7) fournit la génération efficace de nombres de pseudorandom à partir de fils multiples.

meilleur remplacement pour synchronisé est ReentrantLock , qui utilise Lock API

A verrou d'exclusion mutuelle de rentrée avec le même comportement de base et la sémantique que le verrou de moniteur implicite accédé en utilisant des méthodes et des déclarations synchronisées, mais avec des capacités étendues.

exemple avec serrures:

class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }

Consultez de java.util.concurrent et java.util.simultané.les paquets atomiques aussi pour d'autres constructions de programmation.

se référer à ce question connexe trop:

synchronisation vs verrouillage

en général, ils sont généralement les mêmes, sauf qu'ils sont explicites au sujet du moniteur de l'objet qui est utilisé par rapport à l'implicite cet objet. Un inconvénient des méthodes synchronisées qui je pense est parfois négligé est qu'en utilisant la" cette " référence pour synchroniser sur vous laissez ouverte la possibilité d'objets externes se verrouiller sur le même objet. Cela peut être un bug très subtil si vous le rencontrez. La synchronisation sur un objet explicite interne ou un autre champ existant peut éviter ce numéro, encapsulant complètement la synchronisation.

comme déjà dit ici, le bloc synchronisé peut utiliser la variable définie par l'utilisateur comme objet lock, lorsque la fonction synchronisée n'utilise que"ceci". Et bien sûr, vous pouvez manipuler avec des zones de votre fonction qui devrait être synchronisée. Mais tout le monde dit qu'il n'y a pas de différence entre fonction synchronisée et bloc qui couvre l'ensemble de la fonction en utilisant "ceci" comme objet de verrouillage. Ce n'est pas vrai, la différence est dans le code octet qui sera généré dans les deux situations. En cas d'utilisation de blocs synchronisés doit être attribuée variable locale qui détient une référence à "ceci". Et comme résultat, nous aurons un peu plus grande taille pour la fonction (non applicable si vous avez seulement quelques nombre de fonctions).

explication plus détaillée de la différence vous pouvez trouver ici: http://www.artima.com/insidejvm/ed2/threadsynchP.html

dans le cas de méthodes synchronisées, verrouillage sera acquis sur un objet. Mais si vous allez avec le bloc synchronisé vous avez une option pour spécifier un objet sur lequel la serrure sera acquise.

exemple:

    Class Example {
    String test = "abc";
    // lock will be acquired on String  test object.
    synchronized (test) {
        // do something
    }

   lock will be acquired on Example Object
   public synchronized void testMethod() {
     // do some thing
   } 

   }

je sais que c'est une vieille question, mais avec ma lecture rapide des réponses ici, je n'ai pas vraiment vu personne mentionner que parfois une méthode synchronized peut être le faux serrure.

D'après Java Competiency In Practice(p. 72):

public class ListHelper<E> {
  public List<E> list = Collections.syncrhonizedList(new ArrayList<>());
...

public syncrhonized boolean putIfAbsent(E x) {
 boolean absent = !list.contains(x);
if(absent) {
 list.add(x);
}
return absent;
}

le code ci-dessus a l'apparence d'être sans fil. Cependant, en réalité il ne l'est pas. Dans ce cas, la serrure est obtenue sur l'instance du classe. Toutefois, il est possible que le liste soit modifié par un autre fil n'utilisant pas cette méthode. L'approche correcte serait d'utiliser

public boolean putIfAbsent(E x) {
 synchronized(list) {
  boolean absent = !list.contains(x);
  if(absent) {
    list.add(x);
  }
  return absent;
}
}