2. 程式人生 > >並發之無鎖技術歸納

並發之無鎖技術歸納

阿新 • • 發佈：2018-05-21
時間 現象 math 應用 成功 and initials package ray

並發之AtomicBoolean/AtomicBooleanArray/AtomicBooleanUpdateFeild 1 和前面的AtomicInteger很相似或者原理基本一致的；原理就是使用了CAS算法實行循環重試的方式來保證一組操作是原子性的操作； 2 同樣的也是一個無鎖技術的應用； 3 在源碼內部，使用1表示true,使用0表示false; 同樣的boolean類型的變量在並發情況下也是不安全的，因此使用了AtomicBoolean來保障原子性的操作； AtomicReference案例： 和AtomicInteger、AtomicLong原大同小異；只是AtomicLong而言，32位的數分為高16位和低16位分別並行計算；
AtomicReference是一種模板類，可以用來封裝任何類型的數據； 
public class AtomicReference<V> implements java.io.Serializable

package automic;
import java.util.concurrent.atomic.AtomicReference;
public class AtomicRefrenceTest {
     public final static AtomicReference<String> atomicString = new AtomicReference<String>("gosaint");
     
 
/**
      * 創建了10個線程，同時去修改atomicString的值，但是在並發狀態下只有一個可以修改成功！
      * @param args
      */
     public static void main(String[] args) {
         // 開啟10個線程
         for (int i = 0; i < 10; i++) {
              new Thread(new Runnable() {
                  @Override
                  public void run() {
                       
 
try {
                            Thread.sleep(Math.abs((int) Math.random() * 100));
                       } catch (Exception e) {
                            e.printStackTrace();
                       }
                       if (atomicString.compareAndSet("gosaint", "mrc")) {
                            System.out.println(Thread.currentThread().getId() + "Change value");
                       } else {
                            System.out.println(Thread.currentThread().getId() + "Failed");
                       }
                  }
              }).start();
         }
     }
}

看運行結果：只有一個線程對值進行了修改； 
10Change value
9Failed
11Failed
13Failed
14Failed
15Failed
12Failed
16Failed
18Failed
17Failed

CAS的缺點： 其實這個之前說過，為了深刻理解，這裏再說明一下；比如在內存的初始值是3；現在存在兩個線程去修改這個值；根據JVM內存模型；每一個線程都存在這個變量的副本；假設線程1去修改這個值；發現內存中的這個值是3；想要修改為4；但是此時線程2也去修改了內存的值；並且鮮牛該為2，再修改為3，此時線程1發現還是內存還是3，進行了修改；我們看到，雖然對於線程1來說，修改完成了，但是內存中的3確是經過修改2修改過的，這個值得狀態已經發生了變化；如果我們對於某個值的狀態很關註並且這個狀態很重要；那麽這個漏洞必須要避免；這也就是傳說中的“ABA”問題；在JAVA中，通常是對內存中值得每一次修改添加一個時間戳作為版本號，再比較值的時候同樣的時間戳的版本號也要比較； 在AtomicStampedReference類中，存在一個內部類Pair來封裝值和時間戳； 
private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }
 
public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

上面的源碼在比較值得時候時間戳的信息同樣的也進行比較； 
package automic;
import java.util.concurrent.atomic.AtomicStampedReference;
public class AtomicTest {
     /**
      * AtomicStampedReference(V initialRef, int initialStamp)
      *   創建具有給定初始值的新 AtomicStampedReference。
      * @param args
      */
     //創建AtomicStampedReference,用戶的賬戶是19，版本號是0
     static AtomicStampedReference<Integer> asr=new AtomicStampedReference<Integer>(19,0);
     public static void main(String[] args) {
         //創建3個線程給用戶充話費
         for(int i=0;i<3;i++){
              final int expectedStamp = asr.getStamp();//獲取時間戳
              new Thread(new Runnable() {
                  
                  @Override
                  public void run() {
                       while(true){
                            while(true){
                                //獲取值
                                Integer expectedReference = asr.getReference();
                                /**
                                 * 小於20元話費，那麽充值20
                                 */
                                 if(expectedReference<20){
                                     if(asr.compareAndSet(expectedReference, expectedReference+20, expectedStamp, expectedStamp+1)){
                                          System.out.println("充值成功,余額為:"+asr.getReference());
                                          break;
                                     }
                                }else{
                                     break;
                                }
                            }
                       }
                  }
              }).start();
         }
         //啟動100個線程消費
         new Thread(new Runnable() {
              
              @Override
              public void run() {
                  for(int i=0;i<100;i++){
                       while(true){
                            int stamp = asr.getStamp();
                            Integer reference = asr.getReference();
                            if(reference>10){
                                 if(asr.compareAndSet(reference, reference-10, stamp, stamp+1)){
                                      System.out.println("消費10元，余額:"+ asr.getReference());
                             break;
                                }
                            }else{
                                break;
                            }
                       }
                       try{
                             Thread.sleep(100);
                       }catch(Exception e){
                            
                       }
                  }
                  
              }
         }).start();
     }
}

解釋下代碼，有3個線程在給用戶充值，當用戶余額少於20時，就給用戶充值20元。有100個線程在消費，每次消費10元。用戶初始有9元，當使用AtomicStampedReference來實現時，只會給用戶充值一次，因為每次操作使得時間戳+1。運行結果： 
充值成功,余額為:39
消費10元，余額:29
消費10元，余額:19
消費10元，余額:9

　　

代碼修改：修改為AtomicReference類 
package automic;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;
public class AtomicTest2 {
     /**
      * AtomicStampedReference(V initialRef, int initialStamp)
      *   創建具有給定初始值的新 AtomicStampedReference。
      * @param args
      */
     //創建AtomicStampedReference,用戶的賬戶是19，版本號是0
     static AtomicReference<Integer> asr=new AtomicReference<Integer>(19);
     public static void main(String[] args) {
         //創建3個線程給用戶充話費
         for(int i=0;i<3;i++){
              new Thread(new Runnable() {
                  
                  @Override
                  public void run() {
                       while(true){
                            while(true){
                                //獲取值
                                Integer expectedReference = asr.get();
                                /**
                                 * 小於20元話費，那麽充值20
                                 */
                                 if(expectedReference<20){
                                     if(asr.compareAndSet(expectedReference, expectedReference+20)){
                                          System.out.println("充值成功,余額為:"+asr.get());
                                          break;
                                     }
                                }else{
                                     break;
                                }
                            }
                       }
                  }
              }).start();
         }
         //啟動100個線程消費
         new Thread(new Runnable() {
              
              @Override
              public void run() {
                  for(int i=0;i<100;i++){
                       while(true){
                            Integer reference = asr.get();
                            if(reference>10){
                                 if(asr.compareAndSet(reference, reference-10)){
                                      System.out.println("消費10元，余額:"+ asr.get());
                             break;
                                }
                            }else{
                                break;
                            }
                       }
                       try{
                             Thread.sleep(100);
                       }catch(Exception e){
                            
                       }
                  }
                  
              }
         }).start();
     }
}

運行結果：出現了多次充值的現象： 
充值成功,余額為:39
消費10元，余額:29
消費10元，余額:19
充值成功,余額為:39
消費10元，余額:29
消費10元，余額:19
充值成功,余額為:39
消費10元，余額:29
充值成功,余額為:39
消費10元，余額:39
消費10元，余額:29
充值成功,余額為:39
消費10元，余額:39

並發之無鎖技術歸納

相關推薦

並發之無鎖技術歸納

時間 現象 math 應用 成功 and initials package ray 並發之AtomicBoolean/AtomicBooleanArray/AtomicBooleanUpdateFeild 1 和前面的AtomicInteger很相似或者原理基本一致的；原理

如何實現超高並發的無鎖緩存？

class str 高並發 發的 實現 去掉 如何實現 如何 div 在【超高並發】，【寫多讀少】，【定長value】的【業務緩存】場景下： 1）可以通過水平拆分來降低鎖沖突 2）可以通過Map轉Array的方式來最小化鎖沖突，一條記錄一個鎖 3）可以把鎖去掉，最大化並發，

並發之CAS無鎖技術

兩個 javap 執行 update ID get 變量 dset 變化 CAS算法即是：Compare And Swap,比較並且替換； CAS算法存在著三個參數，內存值V，舊的預期值A，以及要更新的值B。當且僅當內存值V和預期值B相等的時候，才會將內存值

java並發之線程同步（synchronized和鎖機制）

blog 是否 can return nbsp jvm 環境 imp ava 使用synchronized實現同步方法 使用非依賴屬性實現同步 在同步塊中使用條件（wait(),notify(),notifyAll()） 使用鎖實現同步 使用讀寫鎖實現同步數據訪問 修改

Java並發編程高階技術 高性能並發框架源碼解析與實戰 高清無密

單線程 內存分析 wait -a 服務 並行 文章 計算框架 ... 第1章 課程介紹（Java並發編程進階課程） 什麽是Disruptor？它一個高性能的異步處理框架，號稱“單線程每秒可處理600W個訂單”的神器，本課程目標：徹底精通一個如此優秀的開源框架，面試秒殺面試官

Java並發- 讀寫鎖中的性能之王：StampedLock

第一個 jdk1.8 轉換 cpu 原生 判斷 四種 空間 blog 為什麽StampedLock這麽神奇？能夠達到這種效果，它的核心思想在於，在讀的時候如果發生了寫，應該通過重試的方式來獲取新的值，而不應該阻塞寫操作。這種模式也就是典型的無鎖編程思想，和CAS自旋的思想一

轉 Java並發之鎖的升級

watermark 描述 並發編程 官方 aced 同時 pla 一個 內容 說明：本文大部分內容來自《並發編程的藝術》，再加上自己網絡整理和理解 以下內容來自《java並發編程的藝術》作者：方鵬飛 魏鵬 程曉明 在多線程並發編程中synchronized一直是元老級角色

多線程並發之原子性(六)

解決 tile start 基本上 barrier stack import 說明 ken 最近在網上找到好多的多線程關於原子性的例子，說的都不是非常的明確，對於剛學習多線程的新手而言很容誤導學員，在這裏，我通過多個例子對多線程的原子性加以說明。 例子一：傳統技術自增

Java並發之Semaphore的使用

enter 天突 的人 釋放 rup catch sys 內部 許可證 Java並發之Semaphore的使用 一.簡介 　　今天突然發現，看著自己喜歡的球隊發揮如此的棒，然後寫著博客，這種感覺很爽。現在是半場時間，就趁著這個時間的空隙，說說Java並發包中另外一個重量級的

高並發下減少鎖競爭

需要 stream 有時 style test consola uri bold eight 1.減少鎖的持有時間，將不需要鎖的操作從同步代碼塊的移除。 //可以優化的代碼 class AttributeStore{ private final Map&l

Java並發之線程間協作Object的wait()、notify()、notifyAll()

它的 ring sleep方法 子類 string exce 程序退出 data- 差異 wait()、notify()和notifyAll()是Object類中的方法： 1）wait()、notify()和notifyAll()方法是本地方法，而且為fina

Java並發之volatile二

inb 有一種 情況 適用於 次數 align 可變 應用程序 new 使用volatilekeyword的場景 Volatile 變量具有 synchronized 的可見性特性。可是不具備原子特性。這就是說線程可以自己主動發現 volatile 變量的最新&#

.NET 並行計算和並發10-lock鎖

list con ask white i++ splay read rgs none 1 class Program 2 { 3 private static List<int> intlist; 4

python並發之多線程

action 互斥 nec data- setname elf 全局 for encoding 一開啟線程的兩種方式 from threading import Thread import time def haha(name): time.sleep(2)

Python並發之協程

記憶 本質 優點 執行權限 執行時間 都是 多線程 效率 ima 《python並發之協程》一： 單線程下實現並發，即只在一個主線程，並且cpu只有一個的情況

Mysql事務，並發問題，鎖機制

記錄 其中 什麽是 原子性 結果 內部 個數 執行 處理 1、什麽是事務 事務是一條或多條數據庫操作語句的組合，具備ACID，4個特點。 原子性：要不全部成功，要不全部撤銷 隔離性：事務之間相互獨立，互不幹擾 一致性：數據庫正確地改變狀態後，數據庫的一致性約束沒有被破壞 持

多線程編程之無鎖隊列

type struct .cn tail 鏈表 erro blank details href 關於無鎖隊列的概念與實現，可以參考博文《無鎖隊列的實現》，主要涉及到的知識點包括CAS原子操作、無鎖隊列的鏈表實現、無鎖隊列的數組實現以及ABA問題。 　　下面借鑒了《多線程的那

java並發之生產者消費者模型

isf tof on() acc sum sca span empty poll 生產者和消費者模型是操作系統中經典的同步問題。該問題最早由Dijkstra提出，用以

高並發情況利用鎖機制處理緩存未命中

然而 ret 直接 .com 適合 key 很好 寫到 javap 關於緩存的使用，個人經驗還是比較欠缺，對於緩存在應用系統中的使用也只是前幾個月在公司實習的時候，簡單的使用過，且使用的都是人家把框架搭建好的，至於緩存在並發情況下會產生的一系列問題都已經被框架處理好

java並發之同步輔助類

ren new read sys art trac final 所有 ber CyclicBarrier 的字面意思是可循環使用（Cyclic）的屏障（Barrier）。它要做的事情是，讓一組線程到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個線程到達屏障時，屏障才會開