一、線程三大特性

多線程有三大特性，原子性、可見性、有序性

1.1 什麽是原子性

即一個操作或者多個操作 要麽全部執行並且執行的過程不會被任何因素打斷，要麽就都不執行。
一個很經典的例子就是銀行賬戶轉賬問題：
比如從賬戶A向賬戶B轉1000元，那麽必然包括2個操作：從賬戶A減去1000元，往賬戶B加上1000元。這2個操作必須要具備原子性才能保證不出現一些意外的問題。
我們操作數據也是如此，比如i = i+1；其中就包括，讀取i的值，計算i，寫入i。這行代碼在Java中是不具備原子性的，則多線程運行肯定會出問題，所以也需要我們使用同步和lock這些東西來確保這個特性了。
原子性其實就是保證數據一致、線程安全一部分，

1.2 什麽是可見性

當多個線程訪問同一個變量時，一個線程修改了這個變量的值，其他線程能夠立即看得到修改的值。
若兩個線程在不同的cpu，那麽線程1改變了i的值還沒刷新到主存，線程2又使用了i，那麽這個i值肯定還是之前的，線程1對變量的修改線程沒看到這就是可見性問題。

1.3什麽是有序性

程序執行的順序按照代碼的先後順序執行。
一般來說處理器為了提高程序運行效率，可能會對輸入代碼進行優化，它不保證程序中各個語句的執行先後順序同代碼中的順序一致，但是它會保證程序最終執行結果和代碼順序執行的結果是一致的。如下：
int a = 10; //語句1
int r = 2; //語句2
a = a + 3; //語句3

二：Java內存模型

共享內存模型指的就是Java內存模型(簡稱JMM)，JMM決定一個線程對共享變量的寫入時,能對另一個線程可見。從抽象的角度來看，JMM定義了線程和主內存之間的抽象關系：線程之間的共享變量存儲在主內存（main memory）中，每個線程都有一個私有的本地內存（local memory），本地內存中存儲了該線程以讀/寫共享變量的副本。本地內存是JMM的一個抽象概念，並不真實存在。它涵蓋了緩存，寫緩沖區，寄存器以及其他的硬件和編譯器優化。

從上圖來看，線程A與線程B之間如要通信的話，必須要經歷下面2個步驟：
1. 首先，線程A把本地內存A中更新過的共享變量刷新到主內存中去。
2. 然後，線程B到主內存中去讀取線程A之前已更新過的共享變量。
下面通過示意圖來說明這兩個步驟：

如上圖所示，本地內存A和B有主內存中共享變量x的副本。假設初始時，這三個內存中的x值都為0。線程A在執行時，把更新後的x值（假設值為1）臨時存放在自己的本地內存A中。當線程A和線程B需要通信時，線程A首先會把自己本地內存中修改後的x值刷新到主內存中，此時主內存中的x值變為了1。隨後，線程B到主內存中去讀取線程A更新後的x值，此時線程B的本地內存的x值也變為了1。
從整體來看，這兩個步驟實質上是線程A在向線程B發送消息，而且這個通信過程必須要經過主內存。JMM通過控制主內存與每個線程的本地內存之間的交互，來為java程序員提供內存可見性保證。

總結：什麽是Java內存模型：java內存模型簡稱jmm，定義了一個線程對另一個線程可見。共享變量存放在主內存中，每個線程都有自己的本地內存，當多個線程同時訪問一個數據的時候，可能本地內存沒有及時刷新到主內存，所以就會發生線程安全問題。

三、Volatile關鍵字

3.1 什麽是Volatile

Volatile 關鍵字的作用是變量在多個線程之間可見。

class ThreadVolatileDemo extends Thread {
    public    boolean flag = true;
    @Override
    public void run() {
        System.out.println("開始執行子線程....");
        while (flag) {
        }
        System.out.println("線程停止");
    }
    public void setRuning(boolean flag) {
        this.flag = flag;
    }

}

public class ThreadVolatile {
    public static void main(String[] args) throws InterruptedException {
        ThreadVolatileDemo threadVolatileDemo = new ThreadVolatileDemo();
        threadVolatileDemo.start();
        Thread.sleep(3000);
        threadVolatileDemo.setRuning(false);
        System.out.println("flag 已經設置成false");
        Thread.sleep(1000);
        System.out.println(threadVolatileDemo.flag);

    }
}

運行結果:

threadVolatileDemo.flag值也是false,可是為什麽程序還是一直在運行呢？

原因:線程之間是不可見的，讀取的是副本，沒有及時讀取到主內存結果。
解決辦法：使用Volatile關鍵字將解決線程之間可見性, 強制線程每次讀取該值的時候都去“主內存”中取值。

3.2 Volatile非原子性

public class VolatileNoAtomic extends Thread {
    private static volatile int count;

    // private static AtomicInteger count = new AtomicInteger(0);
    private static void addCount() {
        for (int i = 0; i < 1000; i++) {
            count++;
            // count.incrementAndGet();
        }
        System.out.println(count);
    }

    public void run() {
        addCount();
    }

    public static void main(String[] args) {

        VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
        // 初始化10個線程
        for (int i = 0; i < 10; i++) {
            arr[i] = new VolatileNoAtomic();
        }

        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
    }

}

運行結果:

結果發現數據不同步，因為Volatile不用具備原子性。所以Volatile只能解決將將結果刷新到主內存中去，並不能解決並發原子性問題。

3.3 使用AtomicInteger原子類

AtomicInteger是一個提供原子操作的Integer類，通過線程安全的方式操作加減，因此十分適合高並發情況下的使用，來源於java並發包。

修改上面的代碼：

public class VolatileNoAtomic extends Thread {

   private static AtomicInteger atomicInteger = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            //等同於count++ 
            atomicInteger.incrementAndGet();
        }
        System.out.println(atomicInteger);
    }

    public static void main(String[] args) {
        // 初始化10個線程
        VolatileNoAtomic[] volatileNoAtomic = new VolatileNoAtomic[10];
        for (int i = 0; i < 10; i++) {
            // 創建
            volatileNoAtomic[i] = new VolatileNoAtomic();
        }
        for (int i = 0; i < volatileNoAtomic.length; i++) {
            volatileNoAtomic[i].start();
        }
    }

}

運行結果：

3.4 volatile與synchronized區別

僅靠volatile不能保證線程的安全性。（原子性）
①volatile輕量級，只能修飾變量。synchronized重量級，還可修飾方法
②volatile只能保證數據的可見性，不能用來同步（沒有原子性，不能保證線程安全），因為多個線程並發訪問volatile修飾的變量不會阻塞。
③synchronized不僅保證可見性，而且還保證原子性，因為，只有獲得了鎖的線程才能進入臨界區，從而保證臨界區中的所有語句都全部執行。多個線程爭搶synchronized鎖對象時，會出現阻塞。
總結：
線程安全性包括兩個方面，①可見性。②原子性。
從上面自增的例子中可以看出：僅僅使用volatile並不能保證線程安全性。而synchronized則可實現線程的安全性。

四、ThreadLoca

4.1、什麽是ThreadLoca

ThreadLocal提高一個線程的局部變量，訪問某個線程擁有自己局部變量。
當使用ThreadLocal維護變量時，ThreadLocal為每個使用該變量的線程提供獨立的變量副本，所以每一個線程都可以獨立地改變自己的副本，而不會影響其它線程所對應的副本。
ThreadLocal的接口方法
ThreadLocal類接口很簡單，只有4個方法，我們先來了解一下：

• void set(Object value)設置當前線程的線程局部變量的值。
• public Object get()該方法返回當前線程所對應的線程局部變量。
• public void remove()將當前線程局部變量的值刪除，目的是為了減少內存的占用，該方法是JDK 5.0新增的方法。需要指出的是，當線程結束後，對應該線程的局部變量將自動被垃圾回收，所以顯式調用該方法清除線程的局部變量並不是必須的操作，但它可以加快內存回收的速度。
• protected Object initialValue()返回該線程局部變量的初始值，該方法是一個protected的方法，顯然是為了讓子類覆蓋而設計的。這個方法是一個延遲調用方法，在線程第1次調用get()或set(Object)時才執行，並且僅執行1次。ThreadLocal中的缺省實現直接返回一個null。

案例:創建三個線程，每個線程生成自己獨立序列號。
代碼:

class Res {
    // 生成序列號共享變量
    //public static Integer count = 0;
    // 設置本地局部變量，與其他線程互不影響
    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
        // 設置當前線程局部變量初始化值
        protected Integer initialValue() {

            return 0;
        };

    };

    public Integer getNum() {
        int count = this.threadLocal.get() + 1;
        this.threadLocal.set(count);
        return count;
    }
}

public class ThreadLocaDemo2 extends Thread {
    private Res res;

    public ThreadLocaDemo2(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + "i---" + i + "--num:" + res.getNum());
        }

    }

    public static void main(String[] args) {
        Res res = new Res();
        ThreadLocaDemo2 threadLocaDemo1 = new ThreadLocaDemo2(res);
        ThreadLocaDemo2 threadLocaDemo2 = new ThreadLocaDemo2(res);
        ThreadLocaDemo2 threadLocaDemo3 = new ThreadLocaDemo2(res);
        threadLocaDemo1.start();
        threadLocaDemo2.start();
        threadLocaDemo3.start();
    }

}

4.2、ThreadLoca實現原理

源碼：

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

從源碼中我們可以看出，ThreadLoca通過map集合，Map.put(“當前線程”,值)；

五、線程池

5.1 什麽是線程池？

線程池是指在初始化一個多線程應用程序過程中創建一個線程集合，然後在需要執行新的任務時重用這些線程而不是新建一個線程。線程池中線程的數量通常完全取決於可用內存數量和應用程序的需求。然而，增加可用線程數量是可能的。線程池中的每個線程都有被分配一個任務，一旦任務已經完成了，線程回到池子中並等待下一次分配任務。

5.2 線程池作用

基於以下幾個原因在多線程應用程序中使用線程是必須的：

1. 線程池改進了一個應用程序的響應時間。由於線程池中的線程已經準備好且等待被分配任務，應用程序可以直接拿來使用而不用新建一個線程。

2. 線程池節省了CLR 為每個短生存周期任務創建一個完整的線程的開銷並可以在任務完成後回收資源。

3. 線程池根據當前在系統中運行的進程來優化線程時間片。

4. 線程池允許我們開啟多個任務而不用為每個線程設置屬性。

5. 線程池允許我們為正在執行的任務的程序參數傳遞一個包含狀態信息的對象引用。

6. 線程池可以用來解決處理一個特定請求最大線程數量限制問題。

5.3 線程池四種創建方式

Java通過Executors（jdk1.5並發包）提供四種線程池，分別為：
newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
newFixedThreadPool 創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。
newScheduledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。

5.4 代碼Demo

newCachedThreadPool

創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。示例代碼如下：

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            // try {
            // Thread.sleep(index * 1000);
            // } catch (InterruptedException e) {
            // e.printStackTrace();
            // }
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "---" + index);
                }
            });
        }

總結: 線程池為無限大，當執行第二個任務時第一個任務已經完成，會復用執行第一個任務的線程，而不用每次新建線程。

newFixedThreadPool

創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。示例代碼如下：

// 創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待
        final ExecutorService newCachedThreadPool = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 10; i++) {
            final int index = i;
            newCachedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                    System.out.println("i:" + index);
                }
            });
        }

總結:因為線程池大小為3，每個任務輸出index後sleep 2秒，所以每兩秒打印3個數字。
定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()

newScheduledThreadPool

創建一個定長線程池，支持定時及周期性任務執行。延遲執行示例代碼如下：

// 創建一個定長線程池，支持定時及周期性任務執行。延遲執行示例代碼如下：
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
        newScheduledThreadPool.schedule(new Runnable() {
            public void run() {
                System.out.println("delay 3 seconds");
            }
        }, 3, TimeUnit.SECONDS);

表示延遲3秒執行。

newSingleThreadExecutor
創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。示例代碼如下：

    ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            newSingleThreadExecutor.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println("index:" + index);
                    try {
                        Thread.sleep(200);
                    } catch (Exception e) {
                        // TODO: handle exception
                    }
                }
            });
        }

註意: 結果依次輸出，相當於順序執行各個任務。

最後推薦篇：JAVA線程池應用的DEMO

Java多線程與並發編程學習