博客鏈接：http://www.ideabuffer.cn/2017/05/07/理解CPU-Cache/
CPU Cache介紹
隨著CPU頻率的不斷提升，內存的訪問速度卻并沒有什么突破。所以，為了彌補內存訪問速度慢的硬傷，便出現了CPU緩存。它的工作原理如下：
- 當CPU要讀取一個數據時，首先從緩存中查找，如果找到就立即讀取并送給CPU處理；
- 如果沒有找到，就用相對慢的速度從內存中讀取并送給CPU處理，同時把這個數據所在的數據塊調入緩存中，可以使得以后對整塊數據的讀取都從緩存中進行，不必再調用內存。
為了充分發揮CPU的計算性能和吞吐量，現代CPU引入了一級緩存、二級緩存和三級緩存，結構如下圖所示：
圖中所示的是三級緩存的架構，可以看到，級別越小的緩存，越接近CPU，但訪問速度也會越慢。
- L1 Cache分為D-Cache和I-Cache，D-Cache用來存儲數據，I-Cache用來存放指令，一般L1 Cache的大小是32k；
- L2 Cache 更大一些,例如256K, 速度要慢一些, 一般情況下每個核上都有一個獨立的L2 Cache；
- L3 Cache是三級緩存中最大的一級，例如12MB，同時也是最慢的一級，在同一個CPU插槽之間的核共享一個L3 Cache。
當CPU計算時，首先去L1去尋找需要的數據，如果沒有則去L2尋找，接著從L3中尋找，如果都沒有，則從內存中讀取數據。所以，如果某些數據需要經常被訪問，那么這些數據存放在L1中的效率會最高。
下面的列表表示了CPU到各緩存和內存之間的大概速度：
| 從CPU到 | 大約需要的CPU周期 | 大約需要的時間(單位ns) |
|---|---|---|
| 寄存器 | 1 cycle | |
| L1 Cache | ~3-4 cycles | ~0.5-1 ns |
| L2 Cache | ~10-20 cycles | ~3-7 ns |
| L3 Cache | ~40-45 cycles | ~15 ns |
| 跨槽傳輸 | ~20 ns | |
| 內存 | ~120-240 cycles | ~60-120ns |
在Linux中可以通過如下命令查看CPU Cache：
cat /sys/devices/system/cpu/cpu0/cache/index0/size
32K
cat /sys/devices/system/cpu/cpu0/cache/index1/size
32K
cat /sys/devices/system/cpu/cpu0/cache/index2/size
256K
cat /sys/devices/system/cpu/cpu0/cache/index3/size
20480K
cat /sys/devices/system/cpu/cpu0/cache/index0/type
Data
cat /sys/devices/system/cpu/cpu0/cache/index1/type
Instruction
這里的index0和index1對應著L1 D-Cache和L1 I-Cache。
緩存行Cache Line
緩存是由緩存行組成的。一般一行緩存行有64字節。CPU在操作緩存時是以緩存行為單位的，可以通過如下命令查看緩存行的大小：
cat /sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size
64
由于CPU存取緩存都是按行為最小單位操作的。對于long類型來說，一個long類型的數據有64位，也就是8個字節，所以對于數組來說，由于數組中元素的地址是連續的，所以在加載數組中第一個元素的時候會把后面的元素也加載到緩存行中。
如果一個long類型的數組長度是8，那么也就是64個字節了，CPU這時操作該數組，會把數組中所有的元素都放入緩存行嗎？答案是否定的，原因就是在Java中，對象在內存中的結構包含對象頭，可以參考我的另一篇文章Java對象內存布局來了解。
測試Cache Miss
下面的代碼引用自http://coderplay.iteye.com/blog/1485760：
public class L1CacheMiss {
private static final int RUNS = 10;
private static final int DIMENSION_1 = 1024 * 1024;
private static final int DIMENSION_2 = 62;
private static long[][] longs;
public static void main(String[] args) throws Exception {
longs = new long[DIMENSION_1][];
for (int i = 0; i < DIMENSION_1; i++) {
longs[i] = new long[DIMENSION_2];
}
System.out.println("starting....");
final long start = System.nanoTime();
long sum = 0L;
for (int r = 0; r < RUNS; r++) {
// 1. slow
for (int j = 0; j < DIMENSION_2; j++) {
for (int i = 0; i < DIMENSION_1; i++) {
sum += longs[i][j];
}
}
// 2. fast
// for (int i = 0; i < DIMENSION_1; i++) {
// for (int j = 0; j < DIMENSION_2; j++) {
// sum += longs[i][j];
// }
// }
}
System.out.println("duration = " + (System.nanoTime() - start));
}
}
這里測試的環境是macOS 10.12.4，JDK 1.8，Java HotSpot(TM) 64-Bit Server VM (build 25.60-b23, mixed mode)。
這里定義了一個二維數組，第一維長度是1024*1024，第二維長度是62，這里遍歷二維數組。由于二維數組中每一個數組對象的長度是62，那么根據上篇文章Java對象內存布局的介紹，可以知道，long類型的數組對象頭的大小是16字節（這里默認開啟了指針壓縮），每個long類型的數據大小是8字節，那么一個long類型的數組大小為16+8*62=512字節。先看一下第一種慢的方式運行的時間：
starting....
duration = 11883939677
運行時間是11秒多，再來看下快的方式：
starting....
duration = 888085368
運行時間是888毫秒，還不到1秒，為什么相差這么多？
首先來分析一下第一種情況，因為二維數組中的每一個數組對象占用的內存大小是512字節，而緩存行的大小是64字節，那么使用第一種遍歷方式，假設當前遍歷的數據是longs[i][j]，那么下一個遍歷的數據是longs[i+1][j]，也就是說遍歷的不是同一個數組對象，那么這兩次遍歷的數據肯定不在同一個緩存行內，也就是產生了Cache Miss；
在第二種情況中，假設當前遍歷的數據是longs[i][j]，那么下一個遍歷的數據是longs[i][j+1]，遍歷的是同一個數組對象，所以當前的數據和下一個要遍歷的數據可能都是在同一個緩存行中，這樣發生Cache Miss的情況就大大減少了。
總結
一般來說，Cache Miss有三種情況：
- 第一次訪問數據時cache中不存在這條數據；
- cache沖突；
- cache已滿。
這里的第二種情況也比較常見，同時會產生一個問題，就是偽共享，有時間會單獨寫一篇文章來介紹一下Java中對偽共享的處理方式。
