Was ist eine Lese-/Schreibsperre?

Wir wissen, dass es kein Problem für mehrere Threads ist, eine Ressourcenklasse gleichzeitig zu lesen. Im Falle der Parallelität sollte das gleichzeitige Lesen gemeinsam genutzter Ressourcen jedoch möglich sein, wenn ein Thread schreiben möchte zu einer gemeinsam genutzten Ressource. Es sollten keine anderen Threads gleichzeitig Lese- oder Schreibzugriff auf die gemeinsam genutzte Ressource haben.

(Empfohlenes Tutorial: Einführung in Java-Tutorial)

Was wir wollen ist: Mehrere Threads gleichzeitig lesen lassen, aber solange ein Thread schreibt, müssen andere Threads warten.

Die Lese-/Schreibsperre basiert auf diesem Prinzip, das heißt, die Lese-/Schreibsperre kann mehreren Multithreads gleichzeitig den Zugriff ermöglichen, aber wenn der Schreibthread zugreift, werden alle Lesethreads und andere Schreibthreads darauf zugreifen blockiert werden. Lese-/Schreibsperren verwalten tatsächlich ein Sperrpaar, eine Lesesperre und eine Schreibsperre. Durch die Trennung von Lesesperren und Schreibsperren wird die Parallelität im Vergleich zu exklusiven Sperren (exklusive Sperren) erheblich verbessert.

Codebeispiel:

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;
    }
}

Ausgabeergebnis:

"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

Effizienz der Lese-/Schreibsperre

(Video-Tutorial-Empfehlung: Java-Video-Tutorial)

Ob die Lese-/Schreibsperre die Leistung der Mutex-Sperre verbessert, hängt davon ab Bei den Daten handelt es sich um die Häufigkeit von Lese- und Änderungsvorgängen, die Dauer von Lese- und Schreibvorgängen sowie um Datenkonflikte und die Anzahl der Threads, die versuchen, Daten gleichzeitig zu lesen oder zu schreiben.

Zum Beispiel ist eine Sammlung, die zunächst mit Daten gefüllt und dann häufig durchsucht wird (z. B. eine Art Verzeichnis), die häufig geändert wird, ein idealer Kandidat für die Verwendung einer Lese-/Schreibsperre. Bei häufigen Aktualisierungen werden die Daten jedoch die meiste Zeit ausschließlich gesperrt, ohne dass die Parallelität zunimmt.

Wenn der Lesevorgang außerdem zu kurz ist, kann der Overhead einer Lese-/Schreibsperren-Implementierung (die selbst komplexer ist als ein Mutex) die Ausführungskosten dominieren, insbesondere da viele Lese-/Schreibsperren-Implementierungen immer noch alle Threads serialisieren durch kleine Abschnitte Code. Letztendlich wird nur durch Profilierung und Messung ermittelt, ob die Verwendung von Lese-/Schreibsperren für Ihre Anwendung geeignet ist.

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