Synchronisations- und Sperrmechanismus von Schnittstellen und abstrakten Klassen in Java

Synchronisationsmechanismus von Schnittstellen und abstrakten Klassen in Java: Schnittstellen und abstrakte Klassen können nicht instanziiert werden und können keine eigenen Sperren haben. Es können synchronisierte Methoden deklariert werden, die gewöhnlichen Methoden ähneln, jedoch mithilfe des synchronisierten Schlüsselworts geändert werden. Wenn eine synchronisierte Methode aufgerufen wird, erhält der Thread die Sperre der Methode. Andere Threads, die gleichzeitig dieselbe Methode aufrufen, werden blockiert, bis die Sperre aufgehoben wird. Praktischer Fall: Die gemeinsam genutzte Ressourcenklasse SharedResource verfügt über zwei Synchronisationsmethoden. Aufgrund der Methodensynchronisation muss der Thread jedoch auf den Zugriff auf die Sperre warten, bevor er den Wert ändert, um die Richtigkeit des Werts sicherzustellen und Parallelität zu vermeiden Probleme.

Synchronisierungs- und Sperrmechanismus von Schnittstellen und abstrakten Klassen in Java

Einführung

Synchronisierung ist ein Mechanismus, um den sicheren Zugriff mehrerer Threads auf gemeinsam genutzte Ressourcen zu gewährleisten. In Java können Sie Sperren verwenden, um eine Synchronisierung zu erreichen. Eine Sperre ist ein Objekt, das, wenn ein Thread eine Sperre anfordert, den Zugriff anderer Threads auf die Ressource blockiert, bis die Sperre aufgehoben wird.

Synchronisation in Schnittstellen und abstrakten Klassen

Schnittstellen und abstrakte Klassen können nicht instanziiert werden, daher können sie keine eigenen Sperren haben. Sie können jedoch synchronisierte Methoden deklarieren, die gewöhnlichen Methoden sehr ähnlich sind, aber mit dem Schlüsselwort synchronized modifiziert werden. 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

Wenn ein Thread eine synchronisierte Methode aufruft, erhält er die Sperre der Methode. Wenn ein anderer Thread gleichzeitig versucht, dieselbe Methode aufzurufen, wird sie blockiert, bis die Sperre aufgehoben wird. 🎜🎜🎜Praktischer Fall🎜🎜🎜Stellen Sie sich eine gemeinsam genutzte Ressourcenklasse SharedResource vor, die über zwei Synchronisationsmethoden verfügt: increment und decrement. 🎜rrreee🎜Jetzt haben wir zwei Threads Thread1 und Thread2, die gleichzeitig auf SharedResource zugreifen. 🎜rrreee🎜In diesem Fall rufen zwei Threads die Methoden inkrementieren und dekrementieren parallel auf, aber da diese Methoden synchronisiert sind, ändert jeder Thread den -Wert Code> muss vorher auf den Zugriff auf das Schloss warten. Dadurch wird sichergestellt, dass der Wert von <code>value immer korrekt ist und keine Parallelitätsprobleme auftreten. 🎜

Das obige ist der detaillierte Inhalt vonSynchronisations- und Sperrmechanismus von Schnittstellen und abstrakten Klassen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!