1. 什麼是偽共享

CPU快取系統中是以快取行（cache line）為單位儲存的。目前主流的CPU Cache的Cache Line大小都是64Bytes。在多執行緒情況下，如果需要修改“共享同一個快取行的變數”，就會無意中影響彼此的效能，這就是偽共享（False Sharing）。

2. 快取行

由於共享變數在CPU快取中的儲存是以快取行為單位，一個快取行可以儲存多個變數（存滿當前快取行的位元組數）；而CPU對快取的修改又是以快取行為最小單位的，那麼就會出現上訴的偽共享問題。

Cache Line可以簡單的理解為CPU Cache中的最小快取單位，今天的CPU不再是按位元組訪問記憶體，而是以64位元組為單位的塊(chunk)拿取，稱為一個快取行(cache line)。當你讀一個特定的記憶體地址，整個快取行將從主存換入快取，並且訪問同一個快取行內的其它值的開銷是很小的。

3. CPU的三級快取

由於CPU的速度遠遠大於記憶體速度，所以CPU設計者們就給CPU加上了快取(CPU Cache)。 以免運算被記憶體速度拖累。（就像我們寫程式碼把共享資料做Cache不想被DB存取速度拖累一樣），CPU Cache分成了三個級別：L1，L2，L3。越靠近CPU的快取越快也越小。所以L1快取很小但很快，並且緊靠著在使用它的CPU核心。L2大一些，也慢一些，並且仍然只能被一個單獨的 CPU 核使用。L3在現代多核機器中更普遍，仍然更大，更慢，並且被單個插槽上的所有 CPU 核共享。最後，你擁有一塊主存，由全部插槽上的所有 CPU 核共享。

當CPU執行運算的時候，它先去L1查詢所需的資料，再去L2，然後是L3，最後如果這些快取中都沒有，所需的資料就要去主記憶體拿。走得越遠，運算耗費的時間就越長。所以如果你在做一些很頻繁的事，你要確保資料在L1快取中。

4. 快取關聯性

目前常用的快取設計是N路組關聯(N-Way Set Associative Cache)，他的原理是把一個快取按照N個Cache Line作為一組（Set），快取按組劃為等分。每個記憶體塊能夠被對映到相對應的set中的任意一個快取行中。比如一個16路快取，16個Cache Line作為一個Set，每個記憶體塊能夠被對映到相對應的Set
中的16個CacheLine中的任意一個。一般地，具有一定相同低bit位地址的記憶體塊將共享同一個Set。
下圖為一個2-Way的Cache。由圖中可以看到Main Memory中的Index0,2,4都對映在Way0的不同CacheLine中，Index1,3,5都對映在Way1的不同CacheLine中。

5. MESI協議

多核CPU都有自己的專有快取（一般為L1，L2），以及同一個CPU插槽之間的核共享的快取（一般為L3）。不同核心的CPU快取中難免會載入同樣的資料，那麼如何保證資料的一致性呢，就是MESI協議了。
在MESI協議中，每個Cache line有4個狀態，可用2個bit表示，它們分別是：
M(Modified)：這行資料有效，資料被修改了，和記憶體中的資料不一致，資料只存在於本Cache中；
E(Exclusive)：這行資料有效，資料和記憶體中的資料一致，資料只存在於本Cache中；
S(Shared)：這行資料有效，資料和記憶體中的資料一致，資料存在於很多Cache中；
I(Invalid)：這行資料無效。

那麼，假設有一個變數i=3（應該是包括變數i的快取塊，塊大小為快取行大小）；已經載入到多核（a,b,c）的快取中，此時該快取行的狀態為S；此時其中的一個核a改變了變數i的值，那麼在核a中的當前快取行的狀態將變為M，b,c核中的當前快取行狀態將變為I。如下圖：

6. 解決原理

為了避免由於false sharing 導致CacheLine從L1,L2,L3到主存之間重複載入，我們可以使用資料填充的方式來避免，即單個數據填充滿一個CacheLine。這本質是一種空間換時間的做法。

7. Java對於偽共享的傳統解決方案

import java.util.concurrent.atomic.AtomicLong;

public final class FalseSharing
    implements Runnable
{
    public final static int NUM_THREADS = 4; // change
    public final static long ITERATIONS = 500L * 1000L * 1000L;
    private final int arrayIndex;

    private static VolatileLong[] longs = new VolatileLong[NUM_THREADS];
    static
    {
        for (int i = 0; i < longs.length; i++)
        {
            longs[i] = new VolatileLong();
        }
    }

    public FalseSharing(final int arrayIndex)
    {
        this.arrayIndex = arrayIndex;
    }

    public static void main(final String[] args) throws Exception
    {
        final long start = System.nanoTime();
        runTest();
        System.out.println("duration = " + (System.nanoTime() - start));
    }

    private static void runTest() throws InterruptedException
    {
        Thread[] threads = new Thread[NUM_THREADS];

        for (int i = 0; i < threads.length; i++)
        {
            threads[i] = new Thread(new FalseSharing(i));
        }

        for (Thread t : threads)
        {
            t.start();
        }

        for (Thread t : threads)
        {
            t.join();
        }
    }

    public void run()
    {
        long i = ITERATIONS + 1;
        while (0 != --i)
        {
            longs[arrayIndex].set(i);
        }
    }

    public static long sumPaddingToPreventOptimisation(final int index)
    {
        VolatileLong v = longs[index];
        return v.p1 + v.p2 + v.p3 + v.p4 + v.p5 + v.p6;
    }

    //jdk7以上使用此方法(jdk7的某個版本oracle對偽共享做了優化)
    public final static class VolatileLong
    {
        public volatile long value = 0L;
        public long p1, p2, p3, p4, p5, p6;
    }

    // jdk7以下使用此方法
    public final static class VolatileLong
    {
        public long p1, p2, p3, p4, p5, p6, p7; // cache line padding
        public volatile long value = 0L;
        public long p8, p9, p10, p11, p12, p13, p14; // cache line padding

    }
}

8. Java8中的解決方案

Java8中已經提供了官方的解決方案，Java8中新增了一個註解：@sun.misc.Contended。加上這個註解的類會自動補齊快取行，需要注意的是此註解預設是無效的，需要在jvm啟動時設定-XX:-RestrictContended才會生效。

@sun.misc.Contended
public final static class VolatileLong {
    public volatile long value = 0L;
    //public long p1, p2, p3, p4, p5, p6;
}

參考文獻