多線程併發與線程安全相關知識整理如下： 一、線程怎麼保證安全性。 什麼是線程安全性 當多個線程訪問某個類時，不管運行時環境採用何種調度方式或者這些進程將如何交替執行，並且在主調代碼中不需要任何額外的同步或協同，這個類都能表現出正確的行為，那麼就稱這個類是線程安全的。 線程安全性的三大特征 原子性、有 ...
多線程併發與線程安全相關知識整理如下：
- 線程怎麼保證安全性
- 如何安全發佈對象
- 線程安全有哪些手段
- JUC組件的講解
- 如何提高線程的調度
一、線程怎麼保證安全性。
- 什麼是線程安全性
當多個線程訪問某個類時，不管運行時環境採用何種調度方式或者這些進程將如何交替執行，並且在主調代碼中不需要任何額外的同步或協同，這個類都能表現出正確的行為，那麼就稱這個類是線程安全的。
- 線程安全性的三大特征
原子性、有序性、可見性
原子性：提供互斥訪問，同一時刻只能有一個線程來對它進行操作。
有序性：一個線程觀察其他線程中的指令執行順序，由於指令重排序的存在，該觀察結果一般雜亂無序。
可見性：一個線程對主記憶體的修改可以及時被其他線程觀察到。
| 特性 | 操作 |
| 原子性 | synchronized的代碼塊能保證串列執行 |
| 有序性 | 可以由volatile（禁止指令重排序）/synchronized（一個變數最多只能有一個線程對其lock）實現 |
| 可見性 | 可以由final(不會修改)、volatile（強制更新+讀取主記憶體）以及synchronized(在unlock時會刷新所有已修改數據到主記憶體，lock時會從主記憶體重新載入數據)實現 |
- 原子性-Atomic包
Java從JDK1.5開始提供了java.util.concurrent.atomic包，方便程式員在多線程環境下，無鎖的進行原子操作。原子變數的底層使用了處理器提供的原子指令，但是不同的CPU架構可能提供的原子指令不一樣，也有可能需要某種形式的內部鎖,所以該方法不能絕對保證線程不被阻塞。
上代碼
package Atomic; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; import java.util.concurrent.atomic.AtomicInteger; //線程安全 public class AtomicIntegerDemo { private final static int clientTotal=5000;//線程總數量 private final static int threadTotal=200;//每次通過的線程數 static AtomicInteger ai=new AtomicInteger(0); public static void main(String[] args) { //線程池 ExecutorService executorService= Executors.newCachedThreadPool(); //生成信號量 final Semaphore semaphore=new Semaphore(threadTotal);//每次通過20個 final CountDownLatch latch=new CountDownLatch(clientTotal);//計數器 for(int i=0;i<clientTotal;i++) { executorService.execute(() -> { try { semaphore.acquire();//申請/獲取許可 //incrementAndGet() //-->1.unsafe.getAndAddInt //-->2.this.compareAndSwapInt（CAS） //-->3.native 方法 //第2->3,實際是工作記憶體與主記憶體校驗的過程(CAS特別重要) ai.incrementAndGet();//數據加1 semaphore.release();//釋放許可 } catch (Exception e) { System.out.println("execption:" + e); } latch.countDown();//計數器減1 }); } try { latch.await(); } catch (InterruptedException e) { e.printStackTrace(); } executorService.shutdown();//關閉線程 System.out.println(ai.get()); } }
- 原子性-鎖（synchronized,lock）
synchronized：依賴JVM，JVM會自動鎖定和解除鎖定
Lock：依賴CPU指令，需要人工解鎖，ReentrantLock
Synchroized代碼
package Sync; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class SynchronizedDemo { //修飾整一個方法 private synchronized void test1(){ for(int i=0;i<10;i++){ System.out.println("Test1 - "+i); } } //修飾某個代碼塊 private void test2(){ synchronized (this){ for(int i=0;i<10;i++){ System.out.println("Test2 - "+i); } } } public static void main(String[] args) { SynchronizedDemo demo1=new SynchronizedDemo(); ExecutorService executorService= Executors.newCachedThreadPool(); executorService.execute(()->{ demo1.test1(); }); executorService.execute(()->{ demo1.test2(); }); executorService.shutdown(); } }
Synchronized對應的作用域如下表
| 操作方法 | 作用域 |
| 修飾某段代碼 | 大括弧括起來的代碼，作用於調用的對象 |
| 修飾方法 | 整個方法，作用於調用的對象 |
| 修飾靜態方法 | 整個靜態方法，作用於所有對象（從JVM原理考慮） |
| 修飾類 | 括弧括起來的部分，作用於所有對象（從JVM原理考慮） |
Lock代碼
package Sync; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockDemo { private static int count=0; private final static int threadPoolCount=5000; private final static int threadCount=200; private static Lock lock=new ReentrantLock(); public static void main(String[] args) { ExecutorService executorService= Executors.newCachedThreadPool();//線程池 Semaphore semaphore=new Semaphore(threadCount); final CountDownLatch countDownLatch = new CountDownLatch(threadPoolCount); for(int i=0;i<threadPoolCount;i++){ executorService.execute(()->{ try { semaphore.acquire(); add(); semaphore.release(); } catch (InterruptedException e) { e.printStackTrace(); } countDownLatch.countDown(); }); } try { countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } executorService.shutdown(); System.out.println(count); } private static void add(){ lock.lock();//鎖定 count++;//需要同步的方法 lock.unlock();//解鎖 } }
Atomic、synchronized、Lock對比
Atomic：在競爭激烈時能維持常態，比Lock性能好，但只能更新一個值
synchronized：不可中斷鎖，適合競爭不激烈，可讀性好，JVM會自動釋放資源。
Lock：可中斷鎖，在競爭激烈時能維持常態，需要人工加鎖與解鎖。
- 可見性
導致共用變數線上程間不可見的原因（線程交叉執行、重排序結合線程交叉執行、共用變數更新後的值沒有在工作記憶體和主存及時更新）
可見性-synchronized
JAVA記憶體模型裡面synchronized的兩條規定：
1.線程解鎖前，必須把共用變數的最新刷新到主記憶體
2.線程加鎖時，將清空工作記憶體中共用變數的值，從而觸發需要使用共用變數時，必須從主記憶體中重新讀取最新的值
可見性-volatile
通過加入記憶體屏障和禁止重排序優化來實現
volatile變數在寫操作時，會在寫操作後加入一個store屏障指令，將本地記憶體中的共用變數值刷新到主記憶體。
volatile變數在讀操作時，會在讀操作前加入一個load屏障指令，從主記憶體讀取共用變數
package Sync; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Semaphore; public class VolatileDemo { private static volatile int count=0; private final static int threadPoolCount=5000; private final static int threadCount=200; public static void main(String[] args) { ExecutorService executorService= Executors.newCachedThreadPool();//線程池 Semaphore semaphore=new Semaphore(threadCount); final CountDownLatch countDownLatch = new CountDownLatch(threadPoolCount); for(int i=0;i<threadPoolCount;i++){ executorService.execute(()->{ try { semaphore.acquire(); add(); semaphore.release(); } catch (InterruptedException e) { e.printStackTrace(); } countDownLatch.countDown(); }); } try { countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } executorService.shutdown(); System.out.println(count); } private static void add(){ //1.第一步獲取count //2.第二步+1 //3.把count的值，返回到主記憶體中 count++; //計算結果顯示Volatile不具有原子性 //Volatile比較適合使用 狀態標記（boolean） //對變數的寫操作不依賴於當前值 //該變數沒有包含在具有其他變數的變數中 } }
- 有序性
JAVA記憶體模型中，允許編譯器和處理器對指令進行重排序，但是重排序過程不會影響到但單線程程式的執行，卻會影響到多線程併發執行的正確性。
happens-before八大原則
程式次序規則：一個線程內，按照代碼的順序執行。
鎖定規則：一個unLock的操作的發生於後面對一個鎖的lock操作。
volatile變數規則：對變數的寫操作先行發生於後面對這個變數的讀操作。
傳遞規則：A操作B，B操作C，那麼可以得出A操作C。
線程啟動規則：Thread對象的start()方法先行發送與此線程的每一個動作。
線程中斷規則：對線程interrupt()方法的調用先行發送與中斷線程的代碼檢測到中斷事件的發生。
線程終結規則：線程中所有的操作終止檢測，可以通過Thread.join()方法來結束。
對象終結規則：一個對象的初始化完成先行發送於他的finalize()方法的開始。
