Quel est le but de passage de paramètre de bloc synchronisé?

Parce qu'il n'a pas d'importance si je passe de la Chaîne d'exemple, Certains aléatoire de la classe de l'instance de la synchronisation de bloc le bloc synchronisé fonctionne parfaitement quel que soit le paramètre passé au bloc.

Le but du paramètre est double:

1. Il permet de synchroniser autres blocs sur le même objet, de sorte que si vous avez deux blocs de code qui peut modifier l'état d'un même objet, ils n'interfèrent pas les uns avec les autres.

   Par exemple:

   public void getSum() {
       int sum = 0;
       synchronized (this.list) {
           for (Thingy t : this.list) {
               sum += t.getValue();
           }
       }
       return sum;
   }
   
   public void addValue(int value) {
       synchronized (this.list) {
           this.list.add(new Thingy(value));
       }
   }

   Là, il est important que nous synchroniser les deux accède à list dans les threads. Nous ne pouvons pas avoir quelque chose d'appel addValue et de buter sur la liste, tandis qu'un autre thread appelle getSum.

2. Il le rend possible pour vous assurer que vous synchronisez avec le bon niveau de granularité. Si vous êtes à sérialiser l'accès à une instance spécifique de la ressource, alors il n'est pas judicieux de le faire dans des instances; vous devriez permettre à plusieurs threads dans le bloc à condition qu'elles soient d'exploitation sur les différentes instances. C'est pourquoi vous synchroniser sur this (ou plus généralement un champ de this) pour une instance spécifique de la ressource, ou de la classe (ou plus généralement un champ de la classe) si il s'agissait d'une ressource statique. De même, il n'y a pas besoin de synchroniser this si vous avez seulement besoin de protéger un domaine spécifique de l'il.

   Par exemple:

   //(In MyClass)
   
   public void getThingySum() {
       int sum = 0;
       synchronized (this.thingyList) {
           for (Thingy t : this.thingyList) {
               sum += t.getValue();
           }
       }
       return sum;
   }
   
   public void addThingy(Thingy t) {
       synchronized (this.thingyList) {
           this.thingyList.add(t);
       }
   }
   
   public void getNiftySum() {
       int sum = 0;
       synchronized (this.niftyList) {
           for (Nifty n : this.niftyList) {
               sum += n.getValue();
           }
       }
       return sum;
   }
   
   public void addNifty(Nifty n) {
       synchronized (this.niftyList) {
           this.niftyList.add(t);
       }
   }

   Là, nous synchroniser l'accès à this.thingyList sur this.thingyList, pas this ou MyClass.class. C'est bien si un thread appelle getThingySum tandis qu'un autre thread appelle addNifty, de sorte que la synchronisation sur les this serait exagéré.

Re votre str exemple:

public  void makeWithdrawal(int amount){
    String str="asd"
    synchronized (str /* pass any non-null object the synchronized block works*/) {
        if(account.getAmount()>10){

            try{
                Thread.sleep(5000);             
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            account.withdraw(amount);
            System.out.println(Thread.currentThread().getName()+" has withdrawn 10, current balance "+ account.getAmount());
        }else{
            System.out.println("Insufficient funds "+account.getAmount());
        }
    }

}

Le commentaire il est incorrect, nonnull instance pas protéger adéquatement le code. La raison ci-dessus semble fonctionner est chaîne de stage: Le même String exemple, est utilisé par tous les threads, parce que les littéraux de chaîne sont automatiquement placés dans la chaîne stagiaire piscine. (Ce qui signifie que vous avez plus de synchronisation; c'est la JVM de l'échelle, pas spécifique à l'instance.) De sorte qu'il fonctionne, mais pas parce que c'est juste n'importe quel objet. Si vous l'avez modifiée à partir de:

String str = "asd";

à

Object o = new Object();

et synchronisés sur qu'il ne ferait rien pour sérialiser l'accès au compte.

Dans votre exemple, la bonne chose à synchroniser sur est this.account.