Was sind die Verwendung und Vorteile der Java-Lese-/Schreibsperre?

Vorwort:

Readers-Writer Lock ist, wie der Name schon sagt, eine Sperre, die in zwei Teile unterteilt ist: eine Lesesperre und eine Schreibsperre. Die Lesesperre ermöglicht den gleichzeitigen Erwerb durch mehrere Threads Der Lesevorgang selbst ist threadsicher, und Schreibsperren sind sich gegenseitig ausschließende Sperren, die nicht zulassen, dass mehrere Threads gleichzeitig Schreibsperren erhalten, und Schreibvorgänge und Lesevorgänge schließen sich ebenfalls gegenseitig aus. Zusammenfassend sind die Merkmale von Lese-/Schreibsperren: Lesen und Lesen schließen sich nicht gegenseitig aus, Lesen und Schreiben schließen sich gegenseitig aus und Schreiben und Schreiben schließen sich gegenseitig aus.

1. Verwendung der Lese-/Schreibsperre

In der Java-Sprache wird die Lese-/Schreibsperre mithilfe der Klasse ReentrantReadWriteLock implementiert, wobei:

• ReentrantReadWriteLock.ReadLock eine Lesesperre darstellt, Dies bietet die Möglichkeit, die Sperrmethode zum Sperren und die Entsperrmethode zum Entsperren zu verwenden. ReentrantReadWriteLock.ReadLock表示读锁，它提供了 lock 方法进行加锁、unlock 方法进行解锁。

• ReentrantReadWriteLock.WriteLock

ReentrantReadWriteLock.WriteLock stellt eine Schreibsperre dar, die die Sperrmethode zum Sperren und die Entsperrmethode zum Entsperren bereitstellt.

Seine grundlegende Verwendung wird im folgenden Code gezeigt:

// 创建读写锁
final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
// 获得读锁
final ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
// 获得写锁
final ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
// 读锁使用
readLock.lock();
try {
    // 业务代码...
} finally {
    readLock.unlock();
}
// 写锁使用
writeLock.lock();
try {
    // 业务代码...
} finally {
    writeLock.unlock();
}

1.1 Lesen und Lesen schließen sich nicht gegenseitig aus

Mehrere Threads können gleichzeitig die Lesesperre erwerben, die als Lesen und Lesen bezeichnet wird schließen sich nicht gegenseitig aus, wie im folgenden Code gezeigt:

// 创建读写锁
final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
// 创建读锁
final ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
Thread t1 = new Thread(() -> {
    readLock.lock();
    try {
        System.out.println("[t1]得到读锁.");
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        System.out.println("[t1]释放读锁.");
        readLock.unlock();
    }
});
t1.start();
Thread t2 = new Thread(() -> {
    readLock.lock();
    try {
        System.out.println("[t2]得到读锁.");
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        System.out.println("[t2]释放读锁.");
        readLock.unlock();
    }
});
t2.start();

Die Ausführungsergebnisse des obigen Programms sind wie folgt:

1.2 Gegenseitiger Lese- und Schreibausschluss

Lesesperre und Schreibsperre schließen sich gegenseitig aus (Das heißt, sie können nicht gleichzeitig abgerufen werden.) Bei gleichzeitiger Verwendung wird dies als gegenseitiger Lese- und Schreibausschluss bezeichnet, wie im folgenden Code gezeigt:

// 创建读写锁
final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
// 创建读锁
final ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
// 创建写锁
final ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
// 使用读锁
Thread t1 = new Thread(() -> {
    readLock.lock();
    try {
        System.out.println("[t1]得到读锁.");
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        System.out.println("[t1]释放读锁.");
        readLock.unlock();
    }
});
t1.start();
// 使用写锁
Thread t2 = new Thread(() -> {
    writeLock.lock();
    try {
        System.out.println("[t2]得到写锁.");
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        System.out.println("[t2]释放写锁.");
        writeLock.unlock();
    }
});
t2.start();

Die Ergebnisse der obigen Programmausführung lauten wie folgt:

1.3 Gegenseitiger Schreib- und Schreibausschluss

Mehrere Threads, die gleichzeitig Schreibsperren verwenden, schließen sich ebenfalls gegenseitig aus, was als gegenseitiger Schreib- und Schreibausschluss bezeichnet wird, wie im folgenden Code gezeigt:

// 创建读写锁
final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
// 创建写锁
final ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
Thread t1 = new Thread(() -> {
    writeLock.lock();
    try {
        System.out.println("[t1]得到写锁.");
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        System.out.println("[t1]释放写锁.");
        writeLock.unlock();
    }
});
t1.start();

Thread t2 = new Thread(() -> {
    writeLock.lock();
    try {
        System.out.println("[t2]得到写锁.");
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        System.out.println("[t2]释放写锁.");
        writeLock.unlock();
    }
});
t2.start();

Das Obige Die Ergebnisse der Programmausführung sind wie folgt: 2. Vorteilsanalyse Lese-/Schreibsperren verbessern die Ausführungsleistung des Programms.

Vermeiden Sie das Lesen temporärer Daten:
• Lesesperre und Schreibsperre sind sich gegenseitig ausschließende Warteschlangenausführungen, die sicherstellen, dass der Lesevorgang keine halbgeschriebenen temporären Daten liest.
  3. Anwendbare Szenarien
• Lese-/Schreibsperren eignen sich für Geschäftsszenarien mit mehr Lese- und weniger Schreibzugriffen. Derzeit haben Lese-/Schreibsperren den größten Vorteil.

Das obige ist der detaillierte Inhalt vonWas sind die Verwendung und Vorteile der Java-Lese-/Schreibsperre?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!