Comment réaliser la synchronisation des threads à l'aide du mécanisme de verrouillage en Java ?

Comment utiliser le mécanisme de verrouillage en Java pour réaliser la synchronisation des threads ?

En programmation multithread, la synchronisation des threads est un concept très important. Lorsque plusieurs threads accèdent et modifient des ressources partagées en même temps, des incohérences de données ou des conditions de concurrence peuvent en résulter. Java fournit un mécanisme de verrouillage pour résoudre ces problèmes et garantir un accès sécurisé aux ressources partagées.

Le mécanisme de verrouillage en Java est fourni par le mot-clé synchronisé et l'interface Lock. Nous apprendrons ensuite comment utiliser ces deux mécanismes pour réaliser la synchronisation des threads.

Exemple d'utilisation du mot-clé synchronisé pour implémenter la synchronisation des threads :

class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

class IncrementThread extends Thread {
    private Counter counter;

    public IncrementThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}

public class SynchronizedExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        IncrementThread thread1 = new IncrementThread(counter);
        IncrementThread thread2 = new IncrementThread(counter);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

Dans l'exemple ci-dessus, la classe Counter a une variable count pour représenter la valeur du compteur. La méthode incrément() est modifiée avec le mot-clé synchronisé, ce qui signifie qu'un seul thread peut accéder et modifier la variable count à tout moment. La méthode getCount() est également modifiée avec le mot-clé synchronisé pour garantir la sécurité des threads lors de l'obtention de la valeur du compteur.

La classe IncrementThread est une classe de thread qui accepte un objet Counter comme paramètre de constructeur et appelle la méthode Increase() dans la méthode run() pour augmenter la valeur du compteur.

Dans le programme principal, nous créons deux threads IncrementThread et les transmettons respectivement à deux instances de thread. Nous démarrons ensuite ces deux threads et attendons qu'ils se terminent à l'aide de la méthode join(). Enfin, nous imprimons la valeur finale du compteur.

Exemple d'utilisation de l'interface Lock pour implémenter la synchronisation des threads :

class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

class IncrementThread extends Thread {
    private Counter counter;

    public IncrementThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}

public class LockExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        IncrementThread thread1 = new IncrementThread(counter);
        IncrementThread thread2 = new IncrementThread(counter);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

Dans l'exemple ci-dessus, l'interface Lock est utilisée dans les méthodes incrément() et getCount() de la classe Counter pour implémenter la synchronisation des threads. Nous créons une instance ReentrantLock pour acquérir et libérer le verrou respectivement au début et à la fin de la méthode.

Le code de la classe IncrementThread et du programme principal est le même que dans l'exemple précédent. Utilisez simplement l'interface Lock au lieu du mot-clé synchronisé dans la classe Counter pour obtenir la synchronisation des threads.

Résumé :

Dans la programmation multi-thread, la synchronisation des threads est un concept important. Java fournit le mot-clé synchronisé et l'interface Lock pour réaliser la synchronisation des threads. Quel que soit le mécanisme utilisé, il peut être garanti qu'un seul thread peut accéder et modifier les ressources partagées à tout moment, garantissant ainsi un accès sécurisé aux threads.

Ce qui précède est un exemple de code permettant d'utiliser le mécanisme de verrouillage en Java pour réaliser la synchronisation des threads. En comprenant et en étudiant ces exemples, nous pouvons mieux appliquer la synchronisation des threads pour garantir l'exactitude et les performances des programmes multithreads.

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!