filtre intrinsèque

Serrure est sur l'objet. Dans Java, chaque objet est un Moniteur

en Java, un verrou intrinsèque est impliqué par chaque utilisation du mot clé synchronisé

Chaque utilisation du mot clé synchronisé est associée à l'un des deux types de verrouillage intrinsèque:

Un "verrouillage d'instance", attaché à un seul objet

Un "verrouillage statique", attaché à une classe

Si une méthode est déclarée synchronisée, elle acquerra la verrouillage de l'instance ou la verrouillage statique lorsqu'elle est appelée, selon qu'il s'agisse d'une méthode d'instance ou d'une méthode statique.

Les deux types de serrure ont un comportement similaire, mais sont complètement indépendants l'un de l'autre.

Acquérir le verrou d'instance ne bloque que d'autres threads d'invoquer une méthode d'instance synchronisée; Il ne bloque pas d'autres threads d'appeler une méthode non synchronisée, ni ne les empêche d'invoquer une méthode synchronisée statique.

De même, l'acquisition de la serrure statique ne bloque que d'autres threads d'appeler une méthode synchronisée statique; Il ne bloque pas d'autres threads d'appeler une méthode non synchronisée, ni ne les bloque d'invoquer une méthode d'instance synchronisée.

En dehors d'un en-tête de méthode, synchronisé (ceci) acquiert le verrou d'instance.

La serrure statique peut être acquise en dehors d'une en-tête de méthode de deux manières:

synchronisé (blac.class), en utilisant la catégorie littérale

synchronisé (this.getclass ()), si un objet est disponible

private int count = 0;
public synchronized void countFunc(){
        count++;
    }
Thread t1 = new Thread(new Runnable(){
            public void run(){
            for(int i=0;i<1000;i++){
                countFunc();
                }}});
        Thread t2 = new Thread(new Runnable(){
            public void run(){
            for(int i=0;i<1000;i++){
                countFunc();
            }}});
In the above example, I have 2 threads trying to increment the value of count. And to prevent thread interleaving I am trying to grab an intrinsic lock by the use of synchronized keyword. Conclusively,
In this example, lock is the method block countFunc with the synchronized keyword and lock is on the count variable.
Hope this helps

Le verrou est sur l'objet.

Regardez la page du didacticiel de Java sur verrous intrinsèque a > p>

Chaque objet a un verrou intrinsèque associé à celui-ci. Par convention, un fil 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 la serrure intrinsèque lorsqu'elle est faite avec elles. On dit qu'un filetage possède le verrou intrinsèque entre le moment où il a acquis la serrure et libéré le verrou. P> BlockQuote>

Tant que le thread possède une serrure intrinsèque, aucun autre thread ne peut acquérir le même verrou. L'autre thread va bloquer lorsqu'il tente d'acquérir la serrure. P>

Deux manières d'utiliser des serrures intrinsèques: P>

1. Méthodes synchronisées: strong> p>

   Lorsqu'un thread invoque une méthode code> synchronisée code>, elle acquiert automatiquement le verrouillage intrinsèque em> strud> pour cet objet de cette méthode et le libère lorsque la méthode revient. p>

   E.g. P> XXX PRE> LI>

2. déclarations synchronisées strong> p>

   Contrairement à Synchronisée CODE> METHODES, Synchronisée CODE> Les instructions doivent spécifier l'objet qui fournit le verrou intrinsèque p>

   public class SynchronizedDemo{
   private int counter = 0;
   
   public SynchronizedDemo(){
   
   }
   public synchronized void incrementCounter(){
       ++counter;
   }
   public int getCounter(){
       synchronized(this){
           return counter;
       }
   }
   public static void main(String[] args){
       SynchronizedDemo object = new SynchronizedDemo();
       for ( int i=0; i < 5; i++){
           Thread t = new Thread(new SimpleRunnable(object));
           t.start();
       }           
   }
   }
   class SimpleRunnable implements Runnable{
   private SynchronizedDemo object;
   
   public SimpleRunnable(SynchronizedDemo obj){
       this.object = obj;
   }
   public void run(){
       object.incrementCounter();
       System.out.println("Counter:"+object.getCounter());
   }
   }