Wie erreichen pessimistische Sperren und optimistische Sperren in Java-Funktionen Thread-Sicherheit?

Zwei Möglichkeiten, Thread-Sicherheit in Java-Funktionen zu erreichen: Pessimistische Sperre: Erwerben Sie die Sperre vor dem Zugriff auf Daten, um den gleichzeitigen Zugriff anderer Threads zu verhindern und die Datenkonsistenz sicherzustellen. (synchronisiertes Schlüsselwort) Optimistische Sperre: Überprüfen Sie die Daten am Ende der Transaktion und setzen Sie die Transaktion zurück, wenn die Daten geändert werden, um die Parallelität zu verbessern. (Atomklasse im Paket java.util.concurrent.atomic)

Wie erreicht man Thread-Sicherheit zwischen pessimistischen Sperren und optimistischen Sperren in Java-Funktionen?

Thread-Sicherheit ist für Multithread-Umgebungen von entscheidender Bedeutung und gewährleistet die Datenintegrität und -konsistenz, wenn gleichzeitig auf Daten zugegriffen wird. In Java sind pessimistisches Sperren und optimistisches Sperren die beiden wichtigsten Mechanismen zum Erreichen der Thread-Sicherheit. Im Folgenden werden wir untersuchen, wie sie umgesetzt werden, und praktische Beispiele liefern.

Pessimistische Sperre

Pessimistische Sperre basiert auf der Annahme, dass Daten jederzeit von anderen Threads geändert werden können. Daher erhält er die Sperre, sobald er auf die Daten zugreift, und verhindert so, dass andere Threads auf die Daten zugreifen, bis die Sperre aufgehoben wird. Der Vorteil des pessimistischen Sperrens besteht darin, dass es die Datenkonsistenz gewährleisten kann. Der Nachteil besteht jedoch darin, dass es zu Sperrkonkurrenz und Deadlock führen kann. Das Schlüsselwort

synchronized ist eine gängige Methode zur Implementierung pessimistischer Sperren in Java. Es markiert einen Codeblock als kritischen Abschnitt und nur der Thread, der die Sperre erhält, kann den Codeblock betreten. synchronized 关键字是 Java 中实现悲观锁的常用方法。它将代码块标记为临界区，只有获取锁的线程才能进入该代码块。

public class Counter {

    private int count;

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

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

乐观锁

乐观锁基于这样的假设：当线程访问数据时，数据不太可能被其他线程修改。它在事务结束时才对数据进行验证，如果数据被修改，则回滚事务。乐观锁的优点是能提高并发性，缺点是如果数据被修改，可能会导致事务失败。

在 Java 中，java.util.concurrent.atomic 包中的原子类可以实现乐观锁。原子类中的操作是原子性的，保证了并发访问数据的正确性。

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {

    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

实战案例：多线程银行账户

为了演示悲观锁和乐观锁在实际场景中的应用，我们考虑一个多线程银行账户。

• 悲观锁实现：

public class BankAccount {

    private int balance;

    public synchronized void withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
        }
    }

    public synchronized int getBalance() {
        return balance;
    }
}

• 乐观锁实现：

import java.util.concurrent.atomic.AtomicInteger;

public class BankAccount {

    private AtomicInteger balance = new AtomicInteger(0);

    public void withdraw(int amount) {
        while (true) {
            int currentBalance = balance.get();
            if (currentBalance >= amount) {
                if (balance.compareAndSet(currentBalance, currentBalance - amount)) {
                    break;
                }
            } else {
                break;
            }
        }
    }

    public int getBalance() {
        return balance.get();
    }
}

使用 optimistic 锁，在取款时，它会获得当前余额，然后尝试使用 compareAndSetrrreee

Optimistisches Sperren

Optimistisches Sperren basiert auf der Annahme, dass es unwahrscheinlich ist, dass die Daten von anderen Threads geändert werden, wenn ein Thread auf Daten zugreift. Es validiert die Daten erst am Ende der Transaktion und setzt die Transaktion zurück, wenn die Daten geändert wurden. Der Vorteil des optimistischen Sperrens besteht darin, dass es die Parallelität verbessern kann. Der Nachteil besteht jedoch darin, dass eine Änderung der Daten dazu führen kann, dass die Transaktion fehlschlägt.

In Java kann die atomare Klasse im Paket java.util.concurrent.atomic optimistisches Sperren implementieren. Die Operationen in der Atomklasse sind atomar und stellen die Korrektheit des gleichzeitigen Zugriffs auf Daten sicher. 🎜rrreee🎜🎜Praktischer Fall: Multithread-Bankkonto🎜🎜🎜Um die Anwendung von pessimistischem Sperren und optimistischem Sperren in praktischen Szenarien zu demonstrieren, betrachten wir ein Multithread-Bankkonto. 🎜

• 🎜Pessimistische Sperrenimplementierung: 🎜

rrreee

• 🎜Optimistische Sperrenimplementierung: 🎜

rrreee🎜Verwenden Sie eine optimistische Sperre während der Auszahlung , ruft es den aktuellen Kontostand ab und versucht dann, den Auszahlungsbetrag mithilfe von compareAndSet atomar zu subtrahieren. Wenn das Guthaben nicht ausreicht, schlägt der Vorgang fehl und der Thread versucht es erneut. 🎜🎜🎜Wählen Sie eine pessimistische Sperre oder eine optimistische Sperre.🎜🎜🎜Die Wahl einer pessimistischen oder optimistischen Sperre hängt vom jeweiligen Szenario ab. Wenn es nur wenige gleichzeitige Zugriffe auf die Daten gibt oder die Datenkonsistenz von entscheidender Bedeutung ist, ist eine pessimistische Sperre besser geeignet. Wenn häufig gleichzeitig auf Daten zugegriffen wird und die Datenkonsistenz ein gewisses Maß an Kompromissen zulässt, ist eine optimistische Sperrung besser geeignet. 🎜

Das obige ist der detaillierte Inhalt vonWie erreichen pessimistische Sperren und optimistische Sperren in Java-Funktionen Thread-Sicherheit?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!