LongAdder-Quellcode-Analyse der gleichzeitigen Java-Programmierung

Vorwort

Lassen Sie uns den grundlegenden Implementierungsprozess anhand des Quellcodes analysieren.

Diese Klasse ist AtomicLong normalerweise vorzuziehen, wenn mehrere Threads eine gemeinsame Summe aktualisieren, die zum Beispiel zum Sammeln von Statistiken verwendet wird, und nicht für eine feinkörnige Synchronisationskontrolle, da die beiden Klassen ähnliche Eigenschaften haben Behauptung, der erwartete Durchsatz dieser Klasse ist deutlich höher, auf Kosten eines höheren Speicherplatzverbrauchs.

Der obige Absatz ist Teil der Quellcode-Kommentare von LongAdder. In der Übersetzung bedeutet er wahrscheinlich LongAdder源码注释中的一部分，翻译过来意思大概是

当多个线程更新用于收集统计信息但不用于细粒度同步控制的目的的公共和时，此类通常优于AtomicLong。 在低更新争用下，这两个类具有相似的特征。 但在高争用的情况下，这一类的预期吞吐量明显更高，但代价是空间消耗更高。

也就是说LongAdder在并发度高的情况下效率更高，但是代价是以空间换时间。

通俗地解释一下LongAdder的原理：当并发少的时候，累加操作只在一个变量base上执行就够用了，所以和AtomicLong类似；但是当并发量上来的时候，如果还是在变量base上进行操作就会有很多线程阻塞，所以就创建一个数组cells，在数组的每一个元素上都可以进行累加，最后计算结果时再就算一下base和cells数组每个元素的和就行了。而线程具体在数组的哪一位进行操作可以通过计算hash来确定索引位置。

源码简介

LongAdder从父类Striped64继承过来的属性，这里的Cell是一个用来进行累加操作的内部类，内部有一个value属性来存储累加的值。

// CPU核心数
static final int NCPU = Runtime.getRuntime().availableProcessors();
// 并发高时进行累加的Cell数组
transient volatile Cell[] cells;
// 多个线程没有竞争时在base上进行累加
transient volatile long base;
// Cell数组是否正在创建或扩容
transient volatile int cellsBusy;

累加操作方法increment()实际调用的是add(1L)，所以我们直接来看add方法

public void add(long x) {
    Cell[] as; long b, v; int m; Cell a;
    if ((as = cells) != null || !casBase(b = base, b + x)) {
        boolean uncontended = true; // 表示没有竞争
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[getProbe() & m]) == null ||
            !(uncontended = a.cas(v = a.value, v + x)))
            longAccumulate(x, null, uncontended);
    }
}

首先来看第一个if语句，初始状况下cells是null，所以会进行casBase操作，也就是在base变量上进行累加，如果操作成功了说明当前没有竞争，所以就结束了。

当并发量上来的时候，进行casBase方法就有可能会失败，所以这时进入第二个if语句判断。

• 第一次进来时Cell数组as是null，所以就会执行longAccumulate，对Cell数组as进行初始化并且在索引1位置累加1；

• 之后再执行到这个if语句as就不是null了，而且数组长度也大于0

• a = as[getProbe() & m]) == null，这句话简单的理解就是在数组as中随机找到一个索引位置，判断该位置的值是不是null，如果是null的话就执行longAccumulate，不是null继续向下判断

• !(uncontended = a.cas(v = a.value, v + x))这句话的意思是，在找到的这个索引位置进行累加操作，如果成功了就结束操作，如果失败了就执行longAccumulate

  Diese Klasse wird im Allgemeinen gegenüber AtomicLong bevorzugt, wenn mehrere Threads eine gemeinsame Summe aktualisieren, die zum Sammeln von Statistiken, aber nicht zum Zweck einer feinkörnigen Synchronisationssteuerung verwendet wird. Bei geringem Aktualisierungskonflikt weisen diese beiden Klassen ähnliche Eigenschaften auf. Unter Bedingungen hoher Konkurrenz ist der erwartete Durchsatz dieser Klasse jedoch deutlich höher, allerdings auf Kosten eines höheren Speicherplatzverbrauchs.

Das heißt, LongAdder ist effizienter, wenn die Parallelität hoch ist, aber der Preis besteht darin, Platz gegen Zeit zu tauschen. 🎜🎜Erklären Sie das Prinzip von LongAdder auf einfache Weise: Wenn wenig Parallelität besteht, reicht es aus, die Akkumulationsoperation nur für eine Variable base durchzuführen, also ist es die wie AtomicLongÄhnlich; wenn jedoch die Parallelität zunimmt und Sie weiterhin mit der Variablen base arbeiten, werden viele Threads blockiert. Erstellen Sie daher ein Array cells code>, die Akkumulation kann für jedes Element des Arrays durchgeführt werden. Bei der Berechnung des Endergebnisses berechnen Sie einfach die Summe jedes Elements der Arrays <code>base und cells. Das spezifische Bit im Array, in dem der Thread arbeitet, kann durch Berechnen des Hash zur Bestimmung der Indexposition ermittelt werden. 🎜🎜Einführung in den Quellcode🎜🎜LongAdder ist ein von der übergeordneten Klasse Striped64 geerbtes Attribut. Die Cell ist hier eine interne Klasse, die für Akkumulationsoperationen verwendet wird . gibt es ein internes value-Attribut zum Speichern des akkumulierten Werts. 🎜rrreee🎜Die Akkumulationsoperationsmethode increment() ruft tatsächlich add(1L) auf, also schauen wir uns die Methode add direkt an🎜rrreee🎜Zuerst Schauen wir uns zunächst die erste if-Anweisung an. In der Ausgangssituation ist cells null, also die casBase Die Operation wird ebenfalls ausgeführt und soll auf der Variablen base akkumuliert werden. Wenn die Operation erfolgreich ist, bedeutet dies, dass derzeit keine Konkurrenz besteht und sie daher beendet ist. 🎜🎜Wenn die Parallelität zunimmt, schlägt die Methode casBase möglicherweise fehl. Daher wird zu diesem Zeitpunkt die zweite Beurteilung der if-Anweisung eingegeben. 🎜

• 🎜Beim ersten Aufruf ist das Cell-Array as null , führt also longAccumulate aus, initialisiert das Cell-Array as und akkumuliert 11 / code>；🎜🎜
• 🎜Nachdem diese if-Anweisung as ausgeführt wurde, ist sie nicht null und die Array-Länge ist ebenfalls größer als 0

🎜🎜

🎜a = as[getProbe() & m]) == null, das einfache Verständnis dieses Satzes ist, dass im Array as Finden Sie zufällig eine Indexposition im Code> und bestimmen Sie, ob der Wert der Position <code>null ist. Wenn er null ist, führen Sie longAccumulateaus >, wenn nicht >nullWeiter nach unten beurteilen🎜🎜

🎜!(uncontended = a.cas(v = a.value, v + x))Dies Satz bedeutet: Führen Sie eine Akkumulationsoperation für die gefundene Indexposition aus. Wenn sie erfolgreich ist, wird die Operation beendet. Wenn sie fehlschlägt, führen Sie longAccumulate aus

Das obige ist der detaillierte Inhalt vonLongAdder-Quellcode-Analyse der gleichzeitigen Java-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!