Quels sont l'utilisation et les avantages du verrouillage en lecture-écriture Java ?

Avant-propos :

Readers-Writer Lock, comme son nom l'indique, est un verrou divisé en deux parties : un verrou en lecture et un verrou en écriture. Le verrou en lecture permet à plusieurs threads de l'acquérir en même temps, car le verrou en lecture permet à plusieurs threads de l'acquérir en même temps, car le verrou en lecture permet à plusieurs threads de l'acquérir en même temps. L'opération de lecture elle-même est thread-safe. , et les verrous d'écriture sont des verrous mutuellement exclusifs, qui ne permettent pas à plusieurs threads d'obtenir des verrous d'écriture en même temps, et les opérations d'écriture et de lecture s'excluent également mutuellement. En résumé, les caractéristiques des verrous en lecture-écriture sont les suivantes : la ​​lecture et la lecture ne s'excluent pas mutuellement, la lecture et l'écriture s'excluent mutuellement, et l'écriture et l'écriture s'excluent mutuellement.

1. Utilisation du verrou en lecture-écriture

En langage Java, le verrouillage en lecture-écriture est implémenté à l'aide de la classe ReentrantReadWriteLock, où :

• ReentrantReadWriteLock.ReadLock représente un verrou en lecture, qui fournit Utilisez la méthode de verrouillage pour verrouiller et la méthode de déverrouillage pour déverrouiller. ReentrantReadWriteLock.ReadLock表示读锁，它提供了 lock 方法进行加锁、unlock 方法进行解锁。

• ReentrantReadWriteLock.WriteLock

ReentrantReadWriteLock.WriteLock représente un verrou en écriture, qui fournit la méthode de verrouillage pour le verrouillage et la méthode de déverrouillage pour le déverrouillage.

Son utilisation de base est indiquée dans le code suivant :

// 创建读写锁
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 Lecture et lecture ne s'excluent pas mutuellement

Plusieurs threads peuvent acquérir le verrou de lecture en même temps, appelé lecture et lecture et sont non mutuellement exclusifs, comme indiqué dans le code suivant :

// 创建读写锁
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();

Les résultats d'exécution du programme ci-dessus sont les suivants :

1.2 Exclusion mutuelle en lecture et en écriture

Le verrouillage en lecture et le verrouillage en écriture s'excluent mutuellement (c'est-à-dire qu'ils ne peuvent pas être obtenus en même temps) lorsqu'ils sont utilisés en même temps. C'est ce qu'on appelle l'exclusion mutuelle de lecture et d'écriture, comme indiqué dans le code suivant :

// 创建读写锁
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();

Les résultats de l'exécution du programme ci-dessus sont les suivants :

1.3 Exclusion mutuelle d'écriture et d'écriture

Plusieurs threads utilisant des verrous d'écriture en même temps s'excluent également mutuellement, ce qui est appelé exclusion mutuelle d'écriture et d'écriture, comme indiqué dans le code suivant :

// 创建读写锁
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();

Ce qui précède les résultats de l'exécution du programme sont les suivants :

• 2. Analyse des avantages

Performances d'exécution du programme améliorées :
• Plusieurs verrous en lecture peuvent être exécutés simultanément, par rapport aux verrous ordinaires qui doivent être mis en file d'attente pour être exécutés en toutes circonstances, les verrous en lecture-écriture améliorent les performances d'exécution du programme.

Évitez de lire des données temporaires :

Le verrouillage en lecture et le verrouillage en écriture sont des exécutions de file d'attente mutuellement exclusives, ce qui garantit que l'opération de lecture ne lira pas de données temporaires à moitié écrites.

3. Scénarios applicables 🎜🎜 Les verrous en lecture-écriture conviennent aux scénarios commerciaux où plus de lecture et moins d'écriture sont nécessaires. À l'heure actuelle, les verrous en lecture-écriture présentent le plus grand avantage. 🎜

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!