Parallele Java-Programmierung: Implementierungsprinzip des gleichzeitigen Containers CopyOnWriteArrayList

Copy-On-Write, kurz COW genannt, ist eine Optimierungsstrategie, die in der Programmierung verwendet wird. Die Grundidee besteht darin, dass jeder den gleichen Inhalt von Anfang an teilt. Wenn jemand den Inhalt ändern möchte, wird er tatsächlich einen neuen Inhalt erstellen und ihn dann ändern. Ab JDK1.5 stellt das Java-Parallelitätspaket zwei gleichzeitige Container bereit, die mithilfe des CopyOnWrite-Mechanismus implementiert werden: CopyOnWriteArrayList und CopyOnWriteArraySet. Der CopyOnWrite-Container ist sehr nützlich und kann in vielen gleichzeitigen Szenarien verwendet werden.

Was ist ein CopyOnWrite-Container

Ein CopyOnWrite-Container ist ein Container, der beim Schreiben kopiert wird. Das gängige Verständnis ist, dass wir beim Hinzufügen von Elementen zu einem Container diese nicht direkt zum aktuellen Container hinzufügen, sondern zuerst den aktuellen Container kopieren, um einen neuen Container zu erstellen, und dann Elemente zum neuen Container hinzufügen. Zeigen Sie dann die Referenz des ursprünglichen Containers auf den neuen Container. Dies hat den Vorteil, dass wir den CopyOnWrite-Container gleichzeitig lesen können, ohne ihn zu sperren, da der aktuelle Container keine Elemente hinzufügt. Daher ist der CopyOnWrite-Container auch eine Idee der Trennung von Lesen und Schreiben, und Lesen und Schreiben sind unterschiedliche Container.

Das Implementierungsprinzip von CopyOnWriteArrayList

Bevor wir CopyOnWriteArrayList verwenden, lesen wir den Quellcode, um zu verstehen, wie es implementiert ist. Der folgende Code ist die Implementierung der Add-Methode in CopyOnWriteArrayList (Hinzufügen von Elementen zu CopyOnWriteArrayList). Es kann festgestellt werden, dass beim Hinzufügen eine Sperre erforderlich ist, da sonst beim Multithread-Schreiben N Kopien kopiert werden.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

/**      * Appends the specified element to the end of this list.      *      * @param e element to be appended to this list      * @return <tt>true</tt> (as specified by {@link Collection#add})      */     public boolean add(E e) {     final ReentrantLock lock = this.lock;     lock.lock();     try {         Object[] elements = getArray();         int len = elements.length;         Object[] newElements = Arrays.copyOf(elements, len + 1);         newElements[len] = e;         setArray(newElements);         return true;     } finally {         lock.unlock();     }     }

1

2

1 2 3

public E get(int index) {     return get(getArray(), index); }

3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

/**      * Hängt das angegebene Element an das Ende dieser Liste an.      *      * @param e-Element, das an diese Liste angehängt werden soll      * @return <tt>true</tt> (wie durch {@link Collection#add} angegeben)      */ public boolean add(E e) { final ReentrantLock lock = this.lock; lock.lock(); versuchen { Object[] elements = getArray(); int len = elements.length; Object[] newElements = Arrays.copyOf(elements, len + 1); newElements[len] = e; setArray(newElements); return true; } endlich { lock.unlock(); } }

Beim Lesen ist keine Sperre erforderlich. Wenn beim Lesen mehrere Threads Daten zu CopyOnWriteArrayList hinzufügen, werden beim Lesen weiterhin die alten Daten gelesen, da beim Schreiben die alte CopyOnWriteArrayList verwendet wird wird nicht gesperrt.

1 2 3

public E get(int index) { return get(getArray(), index); }

CopyOnWriteMap ist im JDK nicht verfügbar. Wir können auf CopyOnWriteArrayList zurückgreifen, um eines zu implementieren. Der Grundcode lautet wie folgt:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import java.util.Collection; import java.util.Map; import java.util.Set;   public class CopyOnWriteMap<K, V> implements Map<K, V>, Cloneable {     private volatile Map<K, V> internalMap;       public CopyOnWriteMap() {         internalMap = new HashMap<K, V>();     }       public V put(K key, V value) {           synchronized (this) {             Map<K, V> newMap = new HashMap<K, V>(internalMap);             V val = newMap.put(key, value);             internalMap = newMap;             return val;         }     }       public V get(Object key) {         return internalMap.get(key);     }       public void putAll(Map<? extends K, ? extends V> newData) {         synchronized (this) {             Map<K, V> newMap = new HashMap<K, V>(internalMap);             newMap.putAll(newData);             internalMap = newMap;         }     } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

import java.util.Collection; import java.util.Map; import java.util.Set; public class CopyOnWriteMap<K, V> implements Map<K, V>, Klonbar { private volatile Map<K, V> internalMap; public CopyOnWriteMap() { internalMap = new HashMap<K, V>(); } public V put(K key, V value) { synchronisiert (dies) { Map<K, V> newMap = new HashMap<K, V>(internalMap); V val = newMap.put(key, value); internalMap = newMap; return val; } } public V get(Object key) { return internalMap.get(key); } public void putAll(Map<? extends K , extends V> newData) { synchronisiert (dies) { Map<K, V> newMap = new HashMap<K, V>(internalMap); newMap.putAll(newData); internalMap = newMap; } } }

Die Implementierung ist sehr einfach. Solange wir den CopyOnWrite-Mechanismus verstehen, können wir verschiedene CopyOnWrite-Container implementieren und in verschiedenen Anwendungsszenarien verwenden.

Anwendungsszenarien von CopyOnWrite

Der gleichzeitige CopyOnWrite-Container wird in gleichzeitigen Szenarien mit mehr Lese- und weniger Schreibvorgängen verwendet. Zum Beispiel Whitelist-, Blacklist- und Produktkategorie-Zugriffs- und Aktualisierungsszenarien. Wenn wir eine Suchwebsite haben, gibt der Benutzer Schlüsselwörter ein, um nach Inhalten in das Suchfeld dieser Website zu suchen, aber einige Schlüsselwörter dürfen nicht durchsucht werden. Diese nicht durchsuchbaren Schlüsselwörter werden in eine Blacklist aufgenommen, die jede Nacht aktualisiert wird. Wenn der Benutzer sucht, prüft er, ob das aktuelle Schlüsselwort in der Blacklist enthalten ist. Wenn dies der Fall ist, wird er darauf hingewiesen, dass die Suche nicht durchgeführt werden kann. Der Implementierungscode lautet wie folgt:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

package com.ifeve.book;   import java.util.Map;   import com.ifeve.book.forkjoin.CopyOnWriteMap;   /**  * 黑名单服务  *  * @author fangtengfei  *  */ public class BlackListServiceImpl {       private static CopyOnWriteMap<String, Boolean> blackListMap = new CopyOnWriteMap<String, Boolean>(             1000);       public static boolean isBlackList(String id) {         return blackListMap.get(id) == null ? false : true;     }       public static void addBlackList(String id) {         blackListMap.put(id, Boolean.TRUE);     }       /**      * 批量添加黑名单      *      * @param ids      */     public static void addBlackList(Map<String,Boolean> ids) {         blackListMap.putAll(ids);     }   }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

Paket com.ifeve.book; import java.util.Map; import com.ifeve.book.forkjoin.CopyOnWriteMap; /**  * 黑名单服务  *  * @author fangtengfei  *  */ public class BlackListServiceImpl { private statisch CopyOnWriteMap<String, Boolean> blackListMap = new CopyOnWriteMap<String, Boolean>( 1000); public static boolean isBlackList(String id) { return blackListMap.get(id) == null ? code>false : true; } public static void addBlackList(String id) { blackListMap.put(id, Boolean.TRUE); } /** * Schwarze Liste stapelweise hinzufügen * * @param ids */ public static void addBlackList(Map<String,Boolean> ids) { Code> blackListMap.putAll(ids); } }

Der Code ist sehr einfach, aber bei der Verwendung von CopyOnWriteMap müssen Sie zwei Dinge beachten:

1. Reduzieren Sie den Erweiterungsaufwand. Initialisieren Sie die Größe von CopyOnWriteMap entsprechend den tatsächlichen Anforderungen, um den Overhead der CopyOnWriteMap-Erweiterung während des Schreibens zu vermeiden.

　2. Verwenden Sie Batch-Add. Da bei jedem Hinzufügen der Container jedes Mal kopiert wird, kann eine Reduzierung der Anzahl der Hinzufügungen die Anzahl der Kopien des Containers verringern. Verwenden Sie beispielsweise die Methode addBlackList im obigen Code.

Nachteile von CopyOnWrite

Der CopyOnWrite-Container hat viele Vorteile, aber es gibt auch zwei Probleme, nämlich Speichernutzung und Datenkonsistenz. Daher müssen Sie bei der Entwicklung darauf achten.

Problem mit der Speichernutzung. Aufgrund des Copy-on-Write-Mechanismus von CopyOnWrite befinden sich bei der Ausführung eines Schreibvorgangs zwei Objekte gleichzeitig im Speicher, das alte Objekt und das neu geschriebene Objekt (Hinweis: Beim Kopieren werden nur die Referenzen im Nur beim Schreiben werden neue Objekte erstellt und dem neuen Container hinzugefügt, während die Objekte im alten Container noch verwendet werden, sodass zwei Kopien des Objektspeichers vorhanden sind. Wenn der von diesen Objekten belegte Speicher relativ groß ist, beispielsweise etwa 200 MB, werden beim Schreiben von 100 MB Daten 300 MB Speicher belegt, was zu diesem Zeitpunkt zu häufigem Yong GC und vollständigem GC führen kann. Zuvor verwendeten wir in unserem System einen Dienst, der den CopyOnWrite-Mechanismus nutzte, um große Objekte jede Nacht zu aktualisieren, was zu einer vollständigen GC von 15 Sekunden jede Nacht führte und auch die Antwortzeit der Anwendung länger wurde.

Angesichts des Speichernutzungsproblems können Sie den Speicherverbrauch großer Objekte reduzieren, indem Sie die Elemente im Container komprimieren. Wenn die Elemente beispielsweise alle Dezimalzahlen sind, können Sie erwägen, sie in Hexadezimalzahlen zu komprimieren Hexadezimalzahlen zur Basis 64. Oder verwenden Sie nicht den CopyOnWrite-Container, sondern andere gleichzeitige Container, z. B. ConcurrentHashMap.

Problem mit der Datenkonsistenz. Der CopyOnWrite-Container kann nur die endgültige Konsistenz der Daten garantieren, nicht jedoch die Echtzeitkonsistenz der Daten. Wenn Sie also möchten, dass die geschriebenen Daten sofort gelesen werden, verwenden Sie bitte nicht den CopyOnWrite-Container.

Verwandte Artikel:

Java Concurrent Programming: CountDownLatch, CyclicBarrier und Semaphore

[JAVA Concurrent Programming Practice] Sperrsequenz Deadlock

Ähnliche Videos:

Video-Tutorial für erweiterte Anwendungen der Java-Multithreading- und Parallelitätsbibliothek

Das obige ist der detaillierte Inhalt vonParallele Java-Programmierung: Implementierungsprinzip des gleichzeitigen Containers CopyOnWriteArrayList. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!