Wie verwende ich Sperren und Synchronisierer in der gleichzeitigen Java-Programmierung?

Java bietet Sperren und Synchronisierer, um den Zugriff auf gemeinsam genutzte Ressourcen zu verwalten. Sperren wie ReentrantLock ermöglichen jeweils nur einem Thread den Zugriff auf einen kritischen Abschnitt, während Synchronisierer wie Semaphore und CountDownLatch eine flexiblere Parallelitätskontrolle bieten, z. B. die Begrenzung der Anzahl der Threads, die gleichzeitig auf eine Ressource zugreifen, oder das Warten darauf, dass alle Threads ihre Aufgaben abgeschlossen haben . Durch die Verwendung dieser Mechanismen können Datenwettläufe wirksam vermieden und die Anwendungsleistung verbessert werden.

Sperren und Synchronisierer in der gleichzeitigen Java-Programmierung

Die gleichzeitige Programmierung ermöglicht die gleichzeitige Ausführung mehrerer Threads, erfordert jedoch Mechanismen zur Verwaltung des Zugriffs auf gemeinsam genutzte Ressourcen. Um dies zu erreichen, stellt Java verschiedene Sperren und Synchronisierer bereit.

Sperren

Sperren ermöglichen jeweils nur einem Thread den Zugriff auf den kritischen Abschnitt (geänderter Teil einer gemeinsam genutzten Ressource). Häufig verwendete Sperren sind:

// 创建一个 ReentrantLock
Lock lock = new ReentrantLock();

// 获取锁
lock.lock();

// 访问临界区
// ...

// 释放锁
lock.unlock();

Synchronizer

Synchronizer sind fortschrittlicher als Sperren und bieten eine flexiblere Parallelitätskontrolle. Häufig verwendete Synchronisierer sind:

Semaphore

Semaphore begrenzt die Anzahl der Threads, die gleichzeitig auf Ressourcen zugreifen können.

// 创建一个 Semaphore，允许最多 3 个线程同时访问
Semaphore semaphore = new Semaphore(3);

// 申请许可证
semaphore.acquire();

// 访问临界区
// ...

// 释放许可证
semaphore.release();

CountDownLatch

CountDownLatch wartet, bis alle Threads ihre Aufgaben abgeschlossen haben, bevor es fortfährt.

// 创建一个 CountDownLatch，等待 10 个线程完成
CountDownLatch latch = new CountDownLatch(10);

// 10 个线程执行任务
// ...

// 每个线程完成后，计数器减一
latch.countDown();

// 主线程等待所有线程完成
latch.await();

Praktischer Fall

Das Folgende ist ein praktischer Fall des Bankkontobetriebs, bei dem Semaphore verwendet wird, um die Anzahl der Threads zu begrenzen, die gleichzeitig auf das Konto zugreifen:

class BankAccount {
    private Semaphore semaphore = new Semaphore(1);
    private double balance;

    public void deposit(double amount) {
        try {
            semaphore.acquire();
            balance += amount;
        } finally {
            semaphore.release();
        }
    }

    public void withdraw(double amount) {
        try {
            semaphore.acquire();
            balance -= amount;
        } finally {
            semaphore.release();
        }
    }
}

Fazit

Sperren und Synchronisierer werden verwendet Verwalten Sie den Zugriff auf gemeinsam genutzte Ressourcen in einem leistungsstarken Java-Tool für die gleichzeitige Programmierung. Durch den sorgfältigen Einsatz dieser Mechanismen können Sie Datenwettläufe effektiv vermeiden und die Programmleistung verbessern.

Das obige ist der detaillierte Inhalt vonWie verwende ich Sperren und Synchronisierer in der gleichzeitigen Java-Programmierung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!