成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

線程安全性詳解(原子性、可見性、有序性)

作者：牧小農(nóng)
開發(fā) 前端
當多個線程訪問某個類時，不管運行時環(huán)境采用 何種調(diào)度方式 或者這些進程將如何交替執(zhí)行，并且在主調(diào)代碼中不需要任何額外的同步或協(xié)同，這個類都能表現(xiàn)出正確的行為，那么就稱這個類就是線程安全的。

[[375148]]

 一、定義：什么是線程安全性

當多個線程訪問某個類時，不管運行時環(huán)境采用 何種調(diào)度方式 或者這些進程將如何交替執(zhí)行，并且在主調(diào)代碼中不需要任何額外的同步或協(xié)同，這個類都能表現(xiàn)出正確的行為，那么就稱這個類就是線程安全的。

二、線程安全性的三個體現(xiàn)

原子性：提供互斥訪問，同一時刻只能有一個線程對數(shù)據(jù)進行操作(Atomic、CAS算法、synchronized、Lock)

可見性：一個主內(nèi)存的線程如果進行了修改，可以及時被其他線程觀察到(synchronized、volatile)

有序性：如果兩個線程不能從 happens-before原則 觀察出來，那么就不能觀察他們的有序性，虛擬機可以隨意的對他們進行重排序，導致其觀察觀察結(jié)果雜亂無序(happens-before原則)

三、線程安全性：原子性

3.1、原子性 — Atomic包

在Java jdk中里面提供了很多Atomic類

  • AtomicXXX：CAS、Unsafe.compareAndSwapInt
  • AtomicLong、LongAdder
  • AtomicReference、AtomicReferenceFieldUpdater
  • AtomicStampReference：CAS的ABA問題

由于CAS原語的直接操作與計算機底層的聯(lián)系很大，CAS原語有三個參數(shù)， 內(nèi)存地址、 期望值、 新值。我們在Java中一般不去直接寫CAS相關(guān)的代碼，JDK為我們封裝在AtomicXXX中，因此，我們直接使用就可以了。

我們在 java.util.concurrent.atomic目錄中可以看到我們這些類，包下提供了 AtomicBoolean、 AtomicLong、 AtomicInteger三種原子更新基本類型和一個比較好玩的類 AtomicReference，這些類都有一個共同點，都支持CAS，以 AtomicInteger為重點講解。


3.1.1、AtomicInteger

AtomicInteger是一個提供原子操作的Integer類，通過線程安全的方式操作加減

以下是 AtomicIntege基本包括的方法：

  1. public final int getAndSet(int newValue)       //給AtomicInteger設(shè)置newValue并返回加oldValue 
  2. public final boolean compareAndSet(int expect, int update)    //如果輸入的值和期望值相等就set并返回true/false 
  3. public final int getAndIncrement()     //對AtomicInteger原子的加1并返回當前自增前的value 
  4. public final int getAndDecrement()   //對AtomicInteger原子的減1并返回自減之前的的value 
  5. public final int getAndAdd(int delta)   //對AtomicInteger原子的加上delta值并返加之前的value 
  6. public final int incrementAndGet()   //對AtomicInteger原子的加1并返回加1后的值 
  7. public final int decrementAndGet()    //對AtomicInteger原子的減1并返回減1后的值 
  8. public final int addAndGet(int delta)   //給AtomicInteger原子的加上指定的delta值并返回加后的值 

示例：

  1. import lombok.extern.slf4j.Slf4j; 
  2.  
  3. import java.util.concurrent.CountDownLatch; 
  4. import java.util.concurrent.ExecutorService; 
  5. import java.util.concurrent.Executors; 
  6. import java.util.concurrent.Semaphore; 
  7. import java.util.concurrent.atomic.AtomicInteger; 
  8.  
  9. @Slf4j 
  10. public class AtomicIntegerExample { 
  11.  
  12.     // 請求總數(shù) 
  13.     public static int clientTotal = 5000; 
  14.  
  15.     // 同時并發(fā)執(zhí)行的線程數(shù) 
  16.     public static int threadTotal = 200; 
  17.  
  18.     public static AtomicInteger count = new AtomicInteger(0); 
  19.  
  20.     public static void main(String[] args) throws Exception { 
  21.       //獲取線程池 
  22.         ExecutorService executorService = Executors.newCachedThreadPool(); 
  23.         //定義信號量 
  24.         final Semaphore semaphore = new Semaphore(threadTotal); 
  25.         final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
  26.         for (int i = 0; i < clientTotal ; i++) { 
  27.             executorService.execute(() -> { 
  28.                 try { 
  29.                     semaphore.acquire(); 
  30.                     add(); 
  31.                     semaphore.release(); 
  32.                 } catch (Exception e) { 
  33.                     log.error("exception", e); 
  34.                 } 
  35.                 countDownLatch.countDown(); 
  36.             }); 
  37.         } 
  38.         countDownLatch.await(); 
  39.         executorService.shutdown(); 
  40.         log.info("count:{}", count.get()); 
  41.     } 
  42.  
  43.     private static void add() { 
  44.         count.incrementAndGet(); 
  45.     } 
  46. } 

這里我們使用請求總數(shù)為：5000，同時執(zhí)行的并發(fā)線程數(shù)為：200，我們最終需要得到結(jié)果為：5000，這個執(zhí)行結(jié)果才算正確。

查看返回結(jié)果：

  1. 13:43:26.473 [main] INFO com.mmall.concurrency.example.atomic.AtomicIntegerExample - count:5000 

最后結(jié)果是 5000表示是線程安全的。

我們來看看 AtomicInteger底層代碼中到底為我們做了什么?首先我們來看 AtomicInteger.incrementAndGet() 方法

  1. public class AtomicInteger extends Number implements java.io.Serializable{ 
  2. /** 
  3.      *  對AtomicInteger原子的加1并返回加1后的值 
  4.      * @return 更新的值 
  5.      */ 
  6.     public final int incrementAndGet() { 
  7.         return unsafe.getAndAddInt(this, valueOffset, 1) + 1; 
  8.     } 
  9. } 

AtomicInteger 調(diào)用了java底層的unsafe.getAndAddInt()```方法，這里是實現(xiàn)CAS 的關(guān)鍵。

incrementAndGet()是將自增后的值返回，還有一個方法 getAndIncrement()是將自增前的值返回，分別對應 ++i和 i++操作。同樣的 decrementAndGet()和 getAndDecrement()則對 --i和i--操作。

  1. Unsafe類是在sun.misc包下，不屬于Java標準。但是很多Java的基礎(chǔ)類庫，包括一些被廣泛使用的高性能開發(fā)庫都是基于 
  2. Unsafe類開發(fā)的，比如Netty、Cassandra、Hadoop、Kafka等。Unsafe類在提升Java運行效率，增強Java語言底層操作 
  3. 能力方面起了很大的作用。Unsafe類使Java擁有了像C語言的指針一樣操作內(nèi)存空間的能力，同時也帶來了指針的問題。 
  4. 過度的使用Unsafe類會使得出錯的幾率變大，因此Java官方并不建議使用的，官方文檔也幾乎沒有。通常我們最好也不 
  5. 要使用Unsafe類，除非有明確的目的，并且也要對它有深入的了解才行。 

再來看 Unsafe.getAndAddInt()方法

  1. /* 
  2.    * 其中g(shù)etIntVolatile和compareAndSwapInt都是native方法 
  3.    * getIntVolatile是獲取當前的期望值 
  4.    * compareAndSwapInt就是我們平時說的CAS(compare and swap)，通過比較如果內(nèi)存區(qū)的值沒有改變，那么就用新值直接給該內(nèi)存區(qū)賦值 
  5.    */ 
  6.     public final int getAndAddInt(Object var1, long var2, int var4) { 
  7.         int var5; 
  8.         do { 
  9.             var5 = this.getIntVolatile(var1, var2); 
  10.         } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); 
  11.         return var5; 
  12.     } 
  13.      
  14.     public native int getIntVolatile(Object var1, long var2); 
  15.     public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); 

我們可以看到 getAndAddInt(Objectvar1,longvar2,intvar4)，傳進來的第一個參數(shù)是當前的一個對象,也就是我們的：count.incrementAndGet()，在 getAndAddInt()中，var1就是count，var2就是當前的值，比如當前循環(huán)中count值為 2，var4為每次遞增1

其次 getAndAddInt()方法中涉及到的兩個方法調(diào)用都定義為native，即java底層實現(xiàn)的本地方法

  • getIntVolatile()：獲取保存當前對象count的主存地址的引用(注意不是對象的值，是引用)。
  • compareAndSwapInt()：比較當前對象的值和底層該對象的值是否相等，如果相等，則將當前對象值加1，如果不相等，則重新去獲取底層該對象的值，這個方法的實現(xiàn)就是CPU的CAS(compare and swap)操作。

我們知道 volatile具有一致性的特征，但是它不具備原子性，為什么 AtomicInteger卻同時具備一致性和原子性，原來在 AtomicInteger源碼中實現(xiàn)了這樣一串代碼：privatevolatileintvalue;，在 AtomicInteger內(nèi)部實現(xiàn)就使用了 volatile關(guān)鍵字，這就是為什么執(zhí)行CAS(對CAS有疑問的點擊此處)操作的時候，從底層獲取的數(shù)據(jù)就是最新的數(shù)據(jù)：

  • 如果當前要保存的值和內(nèi)存中最新的值不相等的話，說明在這個過程中被其他線程修改了，只能獲取更新當前值為最新值，再那這個當前值再去和重新去內(nèi)存獲取的最新值比較，直到二者相等的時候，才完成+1的過程.

使用 AtomicInteger的好處在于，它不同于 sychronized關(guān)鍵字或 lock用鎖的形式來實現(xiàn)原子性，加鎖會影響性能，而是采用循環(huán)比較的形式來提高性能。

3.1.2、AtomicLong

AtomicLong 是作用是對長整形進行原子操作，依靠底層的cas來保障原子性的更新數(shù)據(jù)，在要添加或者減少的時候，會使用死循環(huán)不斷地cas到特定的值，從而達到更新數(shù)據(jù)的目的。

  1. import lombok.extern.slf4j.Slf4j; 
  2.  
  3. import java.util.concurrent.CountDownLatch; 
  4. import java.util.concurrent.ExecutorService; 
  5. import java.util.concurrent.Executors; 
  6. import java.util.concurrent.Semaphore; 
  7. import java.util.concurrent.atomic.AtomicLong; 
  8.  
  9. @Slf4j 
  10. public class AtomicLongExample { 
  11.  
  12.     // 請求總數(shù) 
  13.     public static int clientTotal = 5000; 
  14.  
  15.     // 同時并發(fā)執(zhí)行的線程數(shù) 
  16.     public static int threadTotal = 200; 
  17.  
  18.     public static AtomicLong count = new AtomicLong(0); 
  19.  
  20.     public static void main(String[] args) throws Exception { 
  21.         ExecutorService executorService = Executors.newCachedThreadPool(); 
  22.         final Semaphore semaphore = new Semaphore(threadTotal); 
  23.         final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
  24.         for (int i = 0; i < clientTotal ; i++) { 
  25.             executorService.execute(() -> { 
  26.                 try { 
  27.                     semaphore.acquire(); 
  28.                     add(); 
  29.                     semaphore.release(); 
  30.                 } catch (Exception e) { 
  31.                     log.error("exception", e); 
  32.                 } 
  33.                 countDownLatch.countDown(); 
  34.             }); 
  35.         } 
  36.         countDownLatch.await(); 
  37.         executorService.shutdown(); 
  38.         log.info("count:{}", count.get()); 
  39.     } 
  40.  
  41.     private static void add() { 
  42.         count.incrementAndGet(); 
  43.         // count.getAndIncrement(); 
  44.     } 
  45. } 

執(zhí)行結(jié)果：

  1. 14:59:38.978 [main] INFO com.mmall.concurrency.example.atomic.AtomicLongExample - count:5000 

最后結(jié)果是 5000表示是線程安全的。

3.1.3、AtomicBoolean

AtomicBoolean位于java.util.concurrent.atomic包下，是java提供給的可以保證數(shù)據(jù)的原子性操作的一個類

  1. import lombok.extern.slf4j.Slf4j; 
  2.  
  3. import java.util.concurrent.CountDownLatch; 
  4. import java.util.concurrent.ExecutorService; 
  5. import java.util.concurrent.Executors; 
  6. import java.util.concurrent.Semaphore; 
  7. import java.util.concurrent.atomic.AtomicBoolean; 
  8.  
  9. @Slf4j 
  10. public class AtomicBooleanExample { 
  11.  
  12.     private static AtomicBoolean isHappened = new AtomicBoolean(false); 
  13.  
  14.     // 請求總數(shù) 
  15.     public static int clientTotal = 5000; 
  16.  
  17.     // 同時并發(fā)執(zhí)行的線程數(shù) 
  18.     public static int threadTotal = 200; 
  19.  
  20.     public static void main(String[] args) throws Exception { 
  21.         ExecutorService executorService = Executors.newCachedThreadPool(); 
  22.         final Semaphore semaphore = new Semaphore(threadTotal); 
  23.         final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
  24.         for (int i = 0; i < clientTotal ; i++) { 
  25.             executorService.execute(() -> { 
  26.                 try { 
  27.                     semaphore.acquire(); 
  28.                     test(); 
  29.                     semaphore.release(); 
  30.                 } catch (Exception e) { 
  31.                     log.error("exception", e); 
  32.                 } 
  33.                 countDownLatch.countDown(); 
  34.             }); 
  35.         } 
  36.         countDownLatch.await(); 
  37.         executorService.shutdown(); 
  38.         log.info("isHappened:{}", isHappened.get()); 
  39.     } 
  40.  
  41.     private static void test() { 
  42.         if (isHappened.compareAndSet(false, true)) { 
  43.             log.info("execute"); 
  44.         } 
  45.     } 
  46. } 

返回結(jié)果：

  1. 15:04:54.954 [pool-1-thread-2] INFO com.mmall.concurrency.example.atomic.AtomicBooleanExample - execute 
  2. 15:04:54.971 [main] INFO com.mmall.concurrency.example.atomic.AtomicBooleanExample - isHappened:true 

這里我們發(fā)現(xiàn) log.info("execute");，在代碼中只執(zhí)行了一次，并且 isHappened:true的值為true,這是為啥呢?

這里是因為當程序第一次 compareAndSet()的時候，使得 isHappend變?yōu)榱藅rue，因為原子性的關(guān)系，沒有其他線程進行干擾，通過使用AtomicBoolean，我們使某段代碼只執(zhí)行一次。

3.1.4、AtomicReference

AtomicReference和 AtomicInteger非常類似，不同之處就在于 AtomicInteger是對整數(shù)的封裝，底層采用的是 compareAndSwapInt實現(xiàn)CAS，比較的是數(shù)值是否相等，而 AtomicReference則對應普通的對象引用，底層使用的是 compareAndSwapObject實現(xiàn)CAS，比較的是兩個對象的地址是否相等。也就是它可以保證你在修改對象引用時的線程安全性。

多個線程之間的操作無論采用何種執(zhí)行時序或交替方式，都要保證不變性條件不被破壞，要保持狀態(tài)的一致性，就需要在單個原子操作中更新相關(guān)的狀態(tài)變量。

  1. import lombok.extern.slf4j.Slf4j; 
  2.  
  3. import java.util.concurrent.atomic.AtomicReference; 
  4.  
  5. @Slf4j 
  6. public class AtomicReferenceExample { 
  7.  
  8.     private static AtomicReference<Integer> count = new AtomicReference<>(0); 
  9.  
  10.     public static void main(String[] args) { 
  11.         count.compareAndSet(0, 2);  
  12.         count.compareAndSet(0, 1); 
  13.         count.compareAndSet(1, 3);  
  14.         count.compareAndSet(2, 4);  
  15.         count.compareAndSet(3, 5);  
  16.         log.info("count:{}", count.get()); 
  17.     } 
  18. } 

大家覺得我們輸出的結(jié)果會是多少?

返回結(jié)果：

  1. 15:26:59.680 [main] INFO com.mmall.concurrency.example.atomic.AtomicReferenceExample - count:4 

為什么是4呢?首先我們 要說的是 publicfinalbooleancompareAndSet(V expect,V update)這個方法，這個方法主要的作用是通過比對兩個對象，然后更新為新的對象，這里的比對兩個對象，比對的方式不是 equals而是 ==,意味著比對的是內(nèi)存的中地址。

1、首先我們創(chuàng)建 count的初始化為0

2、在main方法中 count.compareAndSet(0,2);，判斷count為0時賦值為2

3、在 count.compareAndSet(0,1);和 count.compareAndSet(1,3);判斷count是否為1或者0，因為上一步我們已經(jīng)賦值為2了，所以判斷不成立

4、在 count.compareAndSet(2,4);判斷count是否為2，等式成立

5、最好輸出結(jié)果為4

  1. count.compareAndSet(0, 2); //count=0?賦值 2，判斷成立，此時count=0，更新后為2 
  2. count.compareAndSet(0, 1); //count=0?賦值 1，判斷不成立，此時count=2 
  3. count.compareAndSet(1, 3); //count=1?賦值 3，判斷不成立，此時count=2 
  4. count.compareAndSet(2, 4); //count=2?賦值 4，判斷成立，此時count=2，更新后count=4 
  5. count.compareAndSet(3, 5); //count=3?賦值 5，判斷不成立，此時count=4 

所以我們輸出結(jié)果為：4

3.1.5、CAS中ABA問題的解決

CAS并非完美的，它會導致ABA問題，例如：當前內(nèi)存的值一開始是A，被另外一個線程先改為B然后再改為A，那么當前線程訪問的時候發(fā)現(xiàn)是A，則認為它沒有被其他線程訪問過。在某些場景下這樣是存在錯誤風險的。比如在鏈表中。如何解決這個ABA問題呢，大多數(shù)情況下樂觀鎖的實現(xiàn)都會通過引入一個版本號標記這個對象，每次修改版本號都會變話，比如使用時間戳作為版本號，這樣就可以很好的解決ABA問題。在JDK中提供了 AtomicStampedReference類來解決這個問題，這個類維護了一個int類型的標記stamp，每次更新數(shù)據(jù)的時候順帶更新一下stamp。

3.2、原子性 — synchronized

synchronized是一種同步鎖，通過鎖實現(xiàn)原子操作。1、修飾代碼塊：大括號括起來的代碼，作用于調(diào)用的對象 2、修飾方法：整個方法，作用于調(diào)用的對象 3、修飾靜態(tài)方法：整個靜態(tài)方法，作用于所有對象 4、修飾類：括號括起來的部分，作用于所有對象

詳細可以查看，我寫的關(guān)于：synchronized的博客，因為寫過所以就不做過多描述。

3.3、原子性 — 對比

  • Atomic：競爭激烈時能維持常態(tài)，比Lock性能好， 只能同步一個值
  • synchronized：不可中斷鎖，適合競爭不激烈，可讀性好的情況
  • Lock：可中斷鎖，多樣化同步，競爭激烈時能維持常態(tài)

四、線程安全性：可見性

簡介：一個線程對主內(nèi)存的修改可以及時被其他線程觀察到

導致共享變量在線程間不可見的原因：1.線程交叉執(zhí)行 2.重新排序結(jié)合線程交叉執(zhí)行 3.共享變量更新后的值沒有在工作內(nèi)存中與主內(nèi)存間及時更新

4.1 可見性 — syncronized

JMM關(guān)于 syncronized的兩條規(guī)定：

線程解鎖前，必須把共享變量的最新值刷新到主內(nèi)存中

線程加鎖時，將清空工作內(nèi)存中共享變量的值，從而使得使用共享變量時需要從主內(nèi)存中重新讀取最新的值(注意：加鎖與解鎖是同一把鎖) 由于syncronized可以保證原子性及可見性，變量只要被syncronized修飾，就可以放心的使用

4.2 可見性 — volatile

通過加入 內(nèi)存屏障和 禁止重排序優(yōu)化來實現(xiàn)可見性。具體實現(xiàn)過程：

  • 對 volatile變量寫操作時，會在寫操作后加入一條 store屏障指令，將本地內(nèi)存中的共享變量值刷新到主內(nèi)存
  • 對 volatile變量讀操作時，會在讀操作前加入一條 load屏障指令，從主內(nèi)存中讀取共享變量
  • volatile 不能保證操作的原子性，也就是不能保證線程安全性， 如果需要使用 volatile 必須滿足以下兩個條件：
  • 對變量的寫操作不依賴與變量當前的值。
  • 該變量沒有包含在具有其他變量的不變的式子中。

所以 volatile修飾的變量適合作為狀態(tài)標記量。

注：以下圖片為資料中獲取，如有雷同，純屬巧合



示例：

  1. import lombok.extern.slf4j.Slf4j; 
  2.  
  3. import java.util.concurrent.CountDownLatch; 
  4. import java.util.concurrent.ExecutorService; 
  5. import java.util.concurrent.Executors; 
  6. import java.util.concurrent.Semaphore; 
  7.  
  8. @Slf4j 
  9. public class VolatileExample { 
  10.  
  11.     // 請求總數(shù) 
  12.     public static int clientTotal = 5000; 
  13.  
  14.     // 同時并發(fā)執(zhí)行的線程數(shù) 
  15.     public static int threadTotal = 200; 
  16.  
  17.     public static volatile int count = 0; 
  18.  
  19.     public static void main(String[] args) throws Exception { 
  20.         ExecutorService executorService = Executors.newCachedThreadPool(); 
  21.         final Semaphore semaphore = new Semaphore(threadTotal); 
  22.         final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); 
  23.         for (int i = 0; i < clientTotal ; i++) { 
  24.             executorService.execute(() -> { 
  25.                 try { 
  26.                     semaphore.acquire(); 
  27.                     add(); 
  28.                     semaphore.release(); 
  29.                 } catch (Exception e) { 
  30.                     log.error("exception", e); 
  31.                 } 
  32.                 countDownLatch.countDown(); 
  33.             }); 
  34.         } 
  35.         countDownLatch.await(); 
  36.         executorService.shutdown(); 
  37.         log.info("count:{}", count); 
  38.     } 
  39.  
  40.     private static void add() { 
  41.         count++; 
  42.     } 
  43. } 

返回結(jié)果：

  1. 16:12:01.404 [main] INFO com.mmall.concurrency.example.count.VolatileExample4 - count:4986 

通過執(zhí)行代碼我們可以發(fā)現(xiàn)，返回結(jié)果并不是我們想看到的5000，說明這個是線程不安全的類

主要是因為當我們執(zhí)行 conut++時分成了三步：1、取出當前內(nèi)存count值，這時count值時最新的 2、+1操作 3、重新寫回主存

例如：有兩個線程同時在執(zhí)行 count++，兩個內(nèi)存都執(zhí)行了第一步，比如當前count值為99，它們都讀到了這個count值，然后兩個線程分別執(zhí)行了 +1，并寫回主存，這樣就丟掉了一次 +1的操作。

五、線程安全性：有序性

  • 在JMM中，允許編譯器和處理器對指令進行重排序，但是重排序過程不會影響到單線程程序的執(zhí)行，卻會影響到多線程并發(fā)執(zhí)行的正確性。
  • 通過volatile、synchronized、lock保證有序性

5.1 happens-before原則

  • 程序次序規(guī)則：一個線程內(nèi)，按照代碼順序，書寫在前面的操作先行發(fā)生于書寫在后面的操作
  • 鎖定規(guī)則：一個 unLock操作先行發(fā)生于后面對同一個鎖的 Lock()操作，也就是說只有先解鎖才能對下面的線程進行加鎖
  • volatile變量規(guī)則：對一個變量的寫操作先行發(fā)生于后面對這個變量的讀操作
  • 傳遞規(guī)則：如果操作A先行發(fā)生與操作B,而操作B先行發(fā)生于操作C，則操作A先行發(fā)生于操作C
  • 線程啟動規(guī)則： Thread對象的 start()方法先行發(fā)生于此線程的每一個動作，一個線程只有執(zhí)行了 start()方法后才能做其他的操作
  • 線程終端規(guī)則：對線程 interrupt()方法的調(diào)用先行發(fā)生與被中斷線程的代碼檢測到中斷事件的發(fā)生(只有執(zhí)行了 interrupt()方法才可以檢測到中斷事件的發(fā)生)
  • 線程終結(jié)規(guī)則：線程中所有操作都先行發(fā)生于線程的終止檢測，我們可以通過 Thread.join()方法結(jié)束， Thread.isAlive()的返回值手段檢測到線程已經(jīng)終止執(zhí)行
  • 對象終結(jié)規(guī)則：一個對象的初始化完成先行發(fā)生于他的 finalize()方法的開始

六、線程安全性：總結(jié)

  • 原子性：Atomic包、CAS算法、synchronized、Lock
  • 可見性：synchronized、volatile

一個主內(nèi)存的線程如果進行了修改，可以及時被其他線程觀察到，介紹了volatile如何被觀察到的

  • 有序性：happens-before原則 happens-before原則，觀察結(jié)果，如果兩個線程不能偶從happens-before原則觀察出來，那么就不能觀察他們的有序性，虛擬機可以隨意的對他們進行重排序

 

責任編輯：姜華 來源： 牧小碼農(nóng)
線程類線程安全
相關(guān)推薦

2021-05-16 17:14:30

線程安全性

2021-05-06 19:20:05

Java內(nèi)存模型

2024-02-27 17:46:25

并發(fā)程序CPU

2024-11-18 16:37:35

JMMJava內(nèi)存模型

2021-07-03 17:44:34

并發(fā)高并發(fā)原子性

2009-11-30 09:41:38

2023-05-17 08:52:56

Java原子性可見性

2012-12-26 10:53:26

2020-03-04 08:25:18

有序性并發(fā)結(jié)構(gòu)

2024-02-26 08:33:51

并發(fā)編程活躍性安全性

2015-06-15 10:48:25

2013-04-24 10:31:44

公有云云安全

2009-10-23 10:50:04

CLR安全性

2009-11-23 09:07:14

2011-01-04 16:20:26

linux安全性

2016-09-19 21:53:30

Java并發(fā)編程解析volatile

2024-05-13 08:51:39

2020-07-14 10:59:39

云計算云安全技術(shù)

2013-09-18 09:13:16

BYOD安全BYOD自帶設(shè)備辦公

2021-07-30 11:21:39

物聯(lián)網(wǎng)網(wǎng)絡(luò)安全IoT
點贊
收藏

51CTO技術(shù)棧公眾號

主站蜘蛛池模板： 国产乱码高清区二区三区在线 | www.黄色网| www.youjizz.com日韩 | 美女久久| 亚洲最新网址 | 亚洲高清视频一区二区 | 欧美一区在线视频 | 欧美精品一二三区 | 日韩精品1区2区3区 成人黄页在线观看 | 亚洲人在线 | 成人特级毛片 | 91爱爱·com | 亚洲一区二区欧美 | av电影一区二区 | 成人性生交大免费 | 91麻豆产精品久久久久久 | 狠狠狠干 | 欧美性网 | 亚洲性在线 | 久久精品久久久久久 | 台湾佬伊人 | 在线色| 国产一区精品 | a级网站 | 在线永久看片免费的视频 | 97精品国产| 日韩欧美国产精品 | 成人在线精品视频 | 91偷拍精品一区二区三区 | 欧美伊人 | 亚洲高清视频一区二区 | 亚洲男人网 | 久久99精品久久久久久 | 精品国产一区二区三区久久 | 色本道| 99精品99| 欧美日韩三级 | 亚洲精品国产电影 | av电影一区二区 | 91精品入口蜜桃 | 欧美一级久久 |