Un exemple pour comprendre comment utiliser le mot-clé synchronisé en Java

Cet article vous apporte des connaissances pertinentes sur java, qui présente principalement des problèmes liés au mot-clé synchronisé, notamment l'utilisation des méthodes de synchronisation, l'utilisation d'instructions ou de blocs de synchronisation, ce qu'est la synchronisation et pourquoi la synchronisation est nécessaire. regardez le contenu ci-dessous, j’espère qu’il sera utile à tout le monde.

Étude recommandée : "Tutoriel vidéo Java"

Dans le développement quotidien, le mot-clé synchronisé est souvent rencontré. Savez-vous utiliser synchronisé ? Cet article vous le présentera.

Nous avons deux manières d'utiliser la synchronisation :

• En utilisant des méthodes synchronisées
• En utilisant des instructions ou des blocs synchronisés

En utilisant des méthodes synchronisées

Pour rendre une méthode synchronisée, ajoutez simplement le mot-clé synchronisé à sa déclaration :

public class SynchronizedDemo {

    private int i = 0;

    public synchronized void add() {
        i++;
    }

    public synchronized void del() {
        i--;
    }

    public synchronized int getValue() {
        return i;
    }
}

Comme le montre le code ci-dessus, il existe trois méthodes de synchronisation :

• add()
• del()
• getValue()

Chaque méthode ne sera appelée qu'une seule fois pour le même objet en même temps, comme lorsqu'un thread appelle add(), les autres threads seront bloqués jusqu'à ce que le premier thread ait fini de traiter la méthode add().

Utilisez des instructions ou des blocs synchronisés

    public void del(int value){

        synchronized(this){
            this.i -= value;
        }
    }

Dans le code ci-dessus, synchronisé est ajouté avant un code {}, qui représente un bloc de code synchronisé.

Ci-dessus, vous trouverez deux façons d'utiliser le mot-clé synchronisé. Présentons brièvement les concepts liés à la synchronisation.

Qu'est-ce que la synchronisation ?

La synchronisation est un processus qui contrôle plusieurs threads accédant à n'importe quelle ressource partagée, évitant ainsi les résultats incohérents. L'objectif principal de l'utilisation de la synchronisation est d'éviter un comportement incohérent des threads et d'empêcher les interférences des threads.

Vous pouvez utiliser le mot-clé synchronisé en Java pour obtenir des effets de synchronisation synchronisés qui ne peuvent être appliqués qu'aux méthodes et aux blocs, pas aux variables et aux classes.

Pourquoi devons-nous nous synchroniser ?

Tout d'abord, regardons un morceau de code :

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Chaque fois que la méthode incrément() est appelée, la valeur calculée sera augmentée de 1 :

Si elle est appelée 2 fois, 2 seront ajoutées, si appelé 3 fois, 3 seront ajoutés, et s'il est appelé 4 fois, 3 sera ajouté ajoutera 4 :

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Développons maintenant l'exemple ci-dessus et créons un fil pour appeler la méthode incrément() 10 fois :

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                synchronizedDemo.increment();
            }
        });
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Le résultat du calcul à ce moment est comme prévu, le résultat est 10.

C'est une situation monothread, tout va si bien, mais est-ce vraiment le cas ? À quoi cela ressemblerait-il s’il s’agissait d’un environnement multithread ?

Montrons la situation multithread ci-dessous !

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Comme le montre le code ci-dessus, nous avons créé deux threads thread1 et thread2, et chaque thread a appelé incrément() 1000 fois. En théorie, la valeur finale imprimée devrait être 2000, car la valeur changera après que thread1 appelle incrément. () 1000 fois devient 1000. Après que thread2 ait appelé incrément() 1000 fois, la valeur deviendra 2000.

Exécutons-le et voyons le résultat :

Le résultat est différent de ce que nous pensions. que 2000. Exécutons-le à nouveau :

Le résultat est toujours inférieur à 2000.

Pourquoi est-ce ?

Étant donné que le multithread prend en charge le traitement parallèle, il est toujours possible que deux threads obtiennent la valeur du compteur en même temps, et donc tous deux obtiennent la même valeur du compteur, donc dans ce cas, au lieu d'incrémenter la valeur du compteur deux fois, il ne l'incrémente qu'une seule fois.

Alors, comment éviter cette situation ?

Utilisez le mot-clé synchronisé pour le résoudre.

Il suffit d'ajouter synchronisé à la méthode incrément() :

public class SynchronizedDemo {

    int i;

    public synchronized void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Exécutons-la à nouveau à ce moment-là :

Vous pouvez voir que la valeur est 2000.

Nous augmentons le nombre de calculs à 10 000 times :

public class SynchronizedDemo {

    int i;

    public synchronized void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Le résultat de l'exécution est :

On voit qu'un peu de synchronisation résout ce problème si facilement.

Le principe derrière cela est que lorsque le thread 1 exécute la méthode incrément(), il verrouillera automatiquement cette méthode car à ce moment-là, seul le thread 1 possède le verrou, et les autres threads ne peuvent qu'attendre que le thread 1 libère le verrou. lock. Ce n'est qu'après avoir verrouillé le verrou que le thread 2 peut participer à l'appel.

De même, lorsque le thread 2 appelle incrément(), le thread 2 obtient le verrou et le thread 1 attend que le thread 2 libère le verrou. De cette façon, jusqu'à ce que le calcul soit terminé, aucune erreur de calcul ne se produira pendant ce processus.

Résumé

• Le mot-clé synchronisé est le seul moyen de synchroniser un bloc ou une méthode.
• Le mot-clé synchronisé fournit des fonctionnalités de verrouillage, qui garantissent qu'aucune condition de concurrence ne se produit entre les threads. Après avoir été verrouillé, le thread ne peut lire que les données de la mémoire principale. Après avoir lu les données, il vide l'opération d'écriture avant de pouvoir libérer le verrou.
• Le mot-clé synchronisé permet également d'éviter la réorganisation des instructions du programme.

Apprentissage recommandé : "Tutoriel vidéo Java"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!