Qu'est-ce qu'un verrou en lecture-écriture

Nous savons qu'il n'y a aucun problème pour que plusieurs threads lisent une classe de ressources en même temps, donc dans le cas de la concurrence, la lecture des ressources partagées devrait être possible en même temps ; cependant, si un thread souhaite écrire sur une ressource partagée, aucun autre thread ne doit lire ou écrire sur la ressource partagée en même temps.

(Tutoriel recommandé : Tutoriel d'introduction Java)

Ce que nous voulons, c'est : permettre à plusieurs threads de lire en même temps, mais tant qu'un thread écrit, les autres discussions devront attendre.

Le verrouillage en lecture-écriture est basé sur ce principe, c'est-à-dire que le verrouillage en lecture-écriture peut permettre plusieurs accès multi-thread en même temps, mais lorsque le thread d'écriture accède , tous les threads de lecture et autres threads d'écriture seront bloqués. Les verrous en lecture-écriture maintiennent en fait une paire de verrous, un verrou en lecture et un verrou en écriture. En séparant les verrous en lecture et en écriture, sa concurrence est grandement améliorée par rapport aux verrous exclusifs (verrous exclusifs).

Exemple de code :

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        Book book = new Book();//创建一本书，可读可写

        //两个写手
        for (int i = 0; i < 2; i++) {
            int num = i;
            new Thread(()->{
                try {
                    readWriteLock.writeLock().lock();
                    System.out.println("写手"+num+"在写文章");
                    book.write(String.valueOf(num),UUID.randomUUID().toString().substring(0,5));
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    readWriteLock.writeLock().unlock();
                }
            },String.valueOf(i)).start();
        }

        //6个读者
        for (int i = 0; i < 6; i++) {
            int num = i;
            new Thread(()->{
                try {
                    readWriteLock.readLock().lock();
                    String word = book.read(String.valueOf(num % 2));
                    System.out.println("读者"+num+"在阅读文章..."+word);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    readWriteLock.readLock().unlock();
                }
            },String.valueOf(i)).start();
        }
    }
}
class Book{
    HashMap<String, String> map = new HashMap<>();
    public void write(String key,String val){
        map.put(key, val);
    }
    public String read(String key){
        String word = map.get(key);
        return word;
    }
}

Résultat de sortie :

"C:\Program Files\Java\jdk1.8.0_144\bin\java.exe" "-javaagent:F:\MyDir\IDEA\IDEA2018\IntelliJ IDEA 2018.2.4\lib\idea_rt.jar=54141:F:\MyDir\IDEA\IDEA2018\IntelliJ IDEA 2018.2.4\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_144\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_144\jre\lib\rt.jar;E:\idea_workplace\javaBase\target\classes"
写手0在写文章
写手1在写文章
读者0在阅读文章...6b021
读者1在阅读文章...220e4
读者2在阅读文章...6b021
读者4在阅读文章...6b021
读者3在阅读文章...220e4
读者5在阅读文章...220e4

Process finished with exit code 0

Efficacité du verrouillage en lecture-écriture

(Tutoriel vidéo recommandé : Tutoriel vidéo Java)

La question de savoir si les verrous en lecture-écriture amélioreront les performances à l'aide des verrous mutex dépend de la fréquence à laquelle les données sont lues ou modifiées, de la durée des opérations de lecture et d'écriture et des conflits pour les données, essayez le nombre de threads en train de lire ou écrire des données simultanément.

Par exemple, une collection initialement remplie de données, puis fréquemment recherchée (comme un répertoire quelconque) qui est souvent modifiée est un candidat idéal pour l'utilisation d'un verrou en lecture-écriture. Cependant, si les mises à jour deviennent fréquentes, les données seront verrouillées exclusivement la plupart du temps, avec une légère augmentation de la concurrence.

De plus, si l'opération de lecture est trop courte, la surcharge d'une implémentation de verrou en lecture-écriture (qui est elle-même plus complexe qu'un mutex) peut dominer le coût d'exécution, d'autant plus que de nombreuses implémentations de verrou en lecture-écriture le feront sérialisez toujours tous les threads qui passent par de petites portions de code. En fin de compte, seuls le profilage et la mesure détermineront si l'utilisation de verrous en lecture-écriture est appropriée pour votre application.

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!