Mécanisme de synchronisation et de verrouillage des interfaces et classes abstraites en Java

Mécanisme de synchronisation des interfaces et des classes abstraites en Java : Les interfaces et les classes abstraites ne peuvent pas être instanciées et ne peuvent pas avoir leurs propres verrous. Des méthodes synchronisées peuvent être déclarées, qui sont similaires aux méthodes ordinaires mais modifiées à l'aide du mot-clé synchronisé. Lorsqu'une méthode synchronisée est appelée, le thread acquerra le verrou de la méthode. Les autres threads appelant la même méthode en même temps seront bloqués jusqu'à ce que le verrou soit libéré. Cas pratique : La classe de ressources partagée SharedResource dispose de deux méthodes de synchronisation. Cependant, en raison de la synchronisation des méthodes, le thread doit attendre l'accès au verrou avant de modifier la valeur pour garantir l'exactitude de la valeur et éviter la concurrence. problèmes.

Mécanisme de synchronisation et de verrouillage des interfaces et des classes abstraites en Java

Introduction

La synchronisation est un mécanisme permettant de garantir un accès sécurisé aux ressources partagées par plusieurs threads. En Java, vous pouvez utiliser des verrous pour réaliser la synchronisation. Un verrou est un objet qui, lorsqu'un thread demande un verrou, empêche les autres threads d'accéder à la ressource jusqu'à ce que le verrou soit libéré.

Synchronisation dans les interfaces et les classes abstraites

Les interfaces et les classes abstraites ne peuvent pas être instanciées, elles ne peuvent donc pas avoir leurs propres verrous. Cependant, ils peuvent déclarer des méthodes synchronisées, très similaires aux méthodes ordinaires mais modifiées à l'aide du mot-clé synchronized. synchronized 关键字修改。

public interface SynchronizedInterface {

    synchronized void synchronizedMethod();

}

public abstract class SynchronizedAbstractClass {

    synchronized void synchronizedMethod();

}

当某个线程调用同步方法时，它将获取该方法的锁。如果另一个线程尝试同时调用同一个方法，它将被阻塞，直到该锁被释放。

实战案例

考虑一个共享资源类 SharedResource，它具有两个同步方法：increment 和 decrement。

public class SharedResource {

    private int value = 0;

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

    public synchronized void decrement() {
        value--;
    }

}

现在，我们有两个线程 Thread1 和 Thread2，它们并发地访问 SharedResource。

public class Thread1 implements Runnable {

    private SharedResource sharedResource;

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            sharedResource.increment();
        }
    }

}

public class Thread2 implements Runnable {

    private SharedResource sharedResource;

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) {
            sharedResource.decrement();
        }
    }

}

public class Main {

    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();

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

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final value: " + sharedResource.value);
    }

}

在这个案例中，两个线程并行地调用 increment 和 decrement 方法，但由于这些方法是同步的，因此每个线程在修改 value 之前都必须等待对锁的访问。这确保了 valuerrreee

Lorsqu'un thread appelle une méthode synchronisée, il acquiert le verrou de la méthode. Si un autre thread tente d'appeler la même méthode en même temps, il sera bloqué jusqu'à ce que le verrou soit libéré. 🎜🎜🎜Cas pratique🎜🎜🎜Considérons une classe de ressources partagées SharedResource, qui possède deux méthodes de synchronisation : increment et decrement. 🎜rrreee🎜Maintenant, nous avons deux threads Thread1 et Thread2, qui accèdent simultanément à SharedResource. 🎜rrreee🎜Dans ce cas, deux threads appellent les méthodes increment et decrement en parallèle, mais comme ces méthodes sont synchronisées, chaque thread modifie la valeur code> doit attendre l’accès à la serrure avant. Cela garantit que la valeur de <code>value est toujours correcte et qu'aucun problème de concurrence ne survient. 🎜

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!