資訊專欄INFORMATION COLUMN
摘要：的線程機制是搶占式。會讓出當多個線程并發的對主存中的數據進行操作時，有且只有一個會成功，其余均失敗。和對象只有在困難的多線程問題中才是必須的。
并發簡述
并發通常是用于提高運行在單處理器上的程序的性能。在單 CPU 機器上使用多任務的程序在任意時刻只在執行一項工作。
并發編程使得一個程序可以被劃分為多個分離的、獨立的任務。一個線程就是在進程中的一個單一的順序控制流。java的線程機制是搶占式。
線程的好處是提供了輕量級的執行上下文切換，只改變了程序的執行序列和局部變量。
多線程的主要缺陷：
volatile關鍵字等待共享資源的時候性能降低。
需要處理線程的額外 CPU 花費。
糟糕的程序設計導致不必要的復雜度。
有可能產生一些病態行為，若餓死、競爭、死鎖和活鎖。
不同平臺導致的不一樣。
源來：
當程序運行，JVM會為每一個線程分配一個獨立的緩存用于提高執行效率，每一個線程都在自己獨立的緩存中操作各自的數據。一個線程在緩沖中對數據進行修改，寫入到主存后，其他線程無法得知數據已被更改，仍在操作緩存中已過時的數據，為了解決這個問題，提供了volatile關鍵字，實現內存可見，一旦主存數據被修改，便致使其他線程緩存數據行無效，強制前往主存獲取新數據。
Example：內存不可見，導致主線程無法結束。
class ThreadDemo implements Runnable {
//添加volatile關鍵字可實現內存可見性 public volatile boolean flag = false;
public boolean flag = Boolean.false;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
}
flag = Boolean.true;
System.out.println("ThreadDemo over");
}
public boolean isFlag() {
return flag;
}
}
public class TestVolatile {
public static void main(String[] args) {
ThreadDemo demo = new ThreadDemo();
new Thread(demo).start();
while (true) {
if (demo.flag || demo.isFlag()) {
System.out.println("Main over");
break;
}
}
}
}/*output：打印ThreadDemo over，主線程持續循環*/
作用：
當多個線程操作共享數據時，保證內存中的數據可見性。采用底層的內存柵欄，及時的將緩存中修改的數據刷新到主存中，并導致其他線程所緩存的數據無效，使得這些線程必須去主存中獲取修改的數據。
優缺點：
保證內存可見性，讓各個線程能夠彼此獲取最新的內存數據。
較傳統synchronized加鎖操作提高了效率，若有線程正在操作被synchronized修飾的代碼塊數據時，其他線程試圖進行操作，發現已被其他線程占用，試圖操作的線程必須掛起，等到下一次繼續嘗試操作。
對volatile修飾的數據被修改后，其他線程必須前往主存中讀取，若修改頻繁，需要不斷讀取主存數據，效率將會降低。
使用volatile，底層采用內存柵欄，JVM將不會對其提供指令重排序及其優化。
不具備互斥性。多個線程可以同時對數據進行操作，只是由原來的在緩存操作轉變成了直接在主存中操作。（synchronized是互斥的，一個線程正在執行，其他線程必須掛起等待）
不保證變量的原子性。使用volatile僅僅是一個能保證可見性的輕量級同步策略。
原子變量與 CAS 算法Example：使用volatile修飾，number自增問題。
class ThreadDemo implements Runnable {
public volatile int number = 0;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (Exception e) {
}
System.out.print(getIncrementNumber() + " ");
}
public int getIncrementNumber() {
return ++number;
}
}
public class TestAtomic {
public static void main(String[] args) {
ThreadDemo demo = new ThreadDemo();
for (int i = 0; i < 10; i++) {
new Thread(demo).start();
}
}
}/*output: 1 5 4 7 3 9 2 1 8 6 */
// ++number底層原理思想 int temp = number; // ① number = number + 1; // ② temp = number; // ③ return temp; // ④
由 ++number 可知，返回的是 temp 中存儲的值，且自增是一個多步操作，當多個線程調用 incrementNumber方法時，方法去主存中獲取 number 值放入 temp 中，根據 CPU 時間片切換，當 A 線程完成了 ③ 操作時，時間片到了被中斷，A 線程開始執行 ① 時不幸被中斷，接著 A 獲取到了CPU執行權，繼續執行完成 ④ 操作更新了主存中的值，緊接著 B 線程開始執行，但是 B 線程 temp中存儲的值已經過時了。注意：自增操作為四步，只有在第四步的時候才會刷新主存的值，而不是number = number + 1 操作就反映到主存中去。如圖所示：
源來：
volatile只能保證內存可見性，對多步操作的變量，無法保證其原子性，為了解決這個問題，提供了原子變量。
作用：
原子變量既含有volatile的內存可見性，又提供了對變量原子性操作的支持，采用底層硬件對并發操作共享數據的 CAS（Compare-And-Swap）算法，保證數據的原子性。
提供的原子類：
| 類 | 描述 |
|---|---|
| AtomicBoolean | 一個 boolean值可以用原子更新。 |
| AtomicInteger | 可能原子更新的 int值。 |
| AtomicIntegerArray | 一個 int數組，其中元素可以原子更新。 |
|
AtomicIntegerFieldUpdater |
基于反射的實用程序，可以對指定類的指定的 volatile int字段進行原子更新。 |
| AtomicLong | 一個 long值可以用原子更新。 |
| AtomicLongArray | 可以 long地更新元素的 long數組。 |
|
AtomicLongFieldUpdater |
基于反射的實用程序，可以對指定類的指定的 volatile long字段進行原子更新。 |
|
AtomicMarkableReference |
AtomicMarkableReference維護一個對象引用以及可以原子更新的標記位。 |
|
AtomicReference |
可以原子更新的對象引用。 |
|
AtomicReferenceArray |
可以以原子方式更新元素的對象引用數組。 |
|
AtomicReferenceFieldUpdater |
一種基于反射的實用程序，可以對指定類的指定的 volatile volatile引用原子更新。 |
|
AtomicStampedReference |
AtomicStampedReference維護對象引用以及可以原子更新的整數“印記”。 |
| DoubleAccumulator | 一個或多個變量一起維護使用提供的功能更新的運行的值 double 。 |
| DoubleAdder | 一個或多個變量一起保持初始為零 double和。 |
| LongAccumulator | 一個或多個變量，它們一起保持運行 long使用所提供的功能更新值。 |
| LongAdder | 一個或多個變量一起保持初始為零 long總和。 |
CAS算法：
CAS（Compare-And-Swap）是底層硬件對于原子操作的一種算法，其包含了三個操作數：內存值（V），預估值（A），更新值（B）。當且僅當 V == A 時， 執行 V = B 操作；否則不執行任何結果。這里需要注意，A 和 B 兩個操作數是原子性的，同一時刻只能有一個線程進行AB操作。
優缺點：
操作失敗時，直接放棄結果，并不釋放對CPU的控制權，進而可以繼續嘗試操作，不必掛起等待。（synchronized會讓出CPU）
當多個線程并發的對主存中的數據進行操作時，有且只有一個會成功，其余均失敗。
原子變量中封裝了用于對數據的原子操作，簡化了代碼的編寫。
Collection并發類HashMap 與 HashTable簡述
HashMap是線程不安全的，而HashTable是線程安全的，因為HashTable所維護的Hash表存在著獨占鎖，當多個線程并發訪問時，只能有一個線程可進行操作，但是對于復合操作時，HashTable仍然存在線程安全問題，不使用HashTable的主要原因還是效率低下。
// 功能：不包含obj，則添加
if (!hashTable.contains(obj)) {
// 復合操作，執行此處時線程中斷，obj被其他線程添加至容器中，此處繼續執行將導致重復添加
hashTable.put(obj);
}
可知上述兩個操作需要 “原子性”，為了達到效果，還不是得對代碼塊進行同步
ConcurrentHashMap
采用鎖分段機制，分為 16 個段（并發級別），每一個段下有一張表，該表采用鏈表結構鏈接著各個元素，每個段都使用獨立的鎖。當多個線程并發操作的時候，根據各自的級別不同，操作不同的段，多個線程并行操作，明顯提高了效率，其次還提供了復合操作的諸多方法。注：jdk1.8由原來的數組+單向鏈表結構轉換成數據+單向鏈表+紅黑樹結構。
ConcurrentSkipListMap和ConcurrentSkipListSet
有序的哈希表，通過跳表實現，不允許null作為鍵或值。ConcurrentSkipListMap詳解
CopyOnWriteArrayList 和 CopyOnWriteArraySet
對collection進行寫入操作時，將導致創建整個底層數組的副本，而源數組將保留在原地，使得復制的數組在被修改時，讀取操作可以安全的執行。當修改完成時，一個原子性的操作將把心的數組換人，使得新的讀取操作可以看到新的修改。
好處之一是當多個迭代器同時遍歷和修改列表時，不會拋出ConcurrentModificationException。
小結：
當期望許多線程訪問一個給定 collection 時，ConcurrentHashMap 通常優于同步的 HashMap
ConcurrentSkipListMap 通常優于同步的 TreeMap。
當期望的讀數和遍歷遠遠大于列表的更新數時，CopyOnWriteArrayList 優于同步的 ArrayList。
并發迭代操作多時，可選擇CopyOnWriteArrayList 和 CopyOnWriteArraySet。
高并發情況下，可選擇ConcurrentSkipListMap和ConcurrentSkipListSet
CountDownLatch閉鎖源由：
當一個修房子的 A 線程正在執行，需要磚頭時，開啟了一個線程 B 去拉磚頭，此時 A 線程需要等待 B 線程的結果后才能繼續執行時，但是線程之間都是并行操作的，為了解決這個問題，提供了CountDownLatch。
作用：
一個同步輔助類，為了保證執行某些操作時，“所有準備事項都已就緒”，僅當某些操作執行完畢后，才能執行后續的代碼塊，否則一直等待。
CountDownLatch中存在一個鎖計數器，如果鎖計數器不為 0 的話，它會阻塞任何一個調用 await() 方法的線程。也就是說，當一個線程調用 await() 方法時，如果鎖計數器不等于 0，那么就會一直等待鎖計數器為 0 的那一刻，這樣就解決了需要等待其他線程執行完畢才執行的需求。
Example：
class ThreadDemo implements Runnable {
private CountDownLatch latch = null;
public ThreadDemo(CountDownLatch latch) {
this.latch = latch;
}
@Override
public void run() {
try {
System.out.println("execute over");
} finally {
latch.countDown(); // 必須保證計數器減一
}
}
}
public class TestCountDownLatch {
public static void main(String[] args) {
final int count = 10;
final CountDownLatch latch = new CountDownLatch(count);
ThreadDemo demo = new ThreadDemo(latch);
for (int i = 0; i < count; ++i) {
new Thread(demo).start();
}
try {
latch.await(); // 等待計數器為 0
System.out.println("其他線程結束，繼續往下執行...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}/**output：
execute over
...
其他線程結束，繼續往下執行...
*/
細節：
子線程完畢后，必須調用 countDown() 方法使得 鎖計數器減一，否則將會導致調用 await() 方法的線程持續等待，盡可能的放置在 finally 中。
鎖計數器的個數與子線程數最好相等，只要計數器等于 0，不論是否還存在子線程，await() 方法將得到響應，繼續執行后續代碼。
Callable接口源由：
當開啟一個線程執行運算時，可能會需要該線程的計算結果，之前的 implements Runnable 和 extends Thread 的 run() 方法并沒有提供可以返回的功能，因此提供了 Callable接口。 Callable 的運行結果， 需要使用 FutureTask 類來接受。
Example：
