2. 程式人生 > >如何通過Java中的物件值來同步塊

如何通過Java中的物件值來同步塊

阿新 • • 發佈：2019-01-09

問題

有時，我們需要通過變數的值來同步程式碼塊。

為了解這個問題，我們將考慮一個簡單的銀行應用程式，它對客戶的每次轉賬進行以下操作：

  1. 通過此外部Web服務轉移評估現金返還金額（CashBackService）
  2. 在資料庫中執行匯款（AccountService）
  3. 更新現金返還評估系統中的資料（CashBackService）

匯款操作如下：

public  void  withdrawMoney（UUID  userId，int  amountOfMoney）{
    synchronized（userId）{  
        結果 result  =  externalCashBackService。evaluateCashBack（userId，amountOfMoney）;
 
        accountService。轉移（使用者id，amountOfMoney  +  結果。getCashBackAmount（））;
        externalCashBackService。cashBackComplete（使用者id，結果。getCashBackAmount（））;
    }
}

 

應用程式的基本元件如下圖所示：

應用程式的元件圖

我試圖儘可能清楚地做出一個例子。支付服務中的資金轉移取決於其他兩項服​​務：

  • 第一個是CashBackService與REST協議下的另一個（外部）Web應用程式互動。而且，為了計算實際的現金返還，我們需要與此應用程式同步事務。這是因為下一筆現金返還金額可能取決於使用者付款總額。
  • 第二個是AccountService與內部資料庫通訊並存儲與其使用者帳戶相關的資料。在此服務中，我們可以使用JPA事務在資料庫中將某些操作作為原子操作。

在現實生活中，我強烈建議重構這樣的系統，以避免這種情況，如果可能的話。但在我們的例子中，想象一下我們別無選擇。

我們來看看這個應用程式的草案程式碼：

@服務
公共 類 PaymentService {
 
    @Autowired
    private  ExternalCashBackService  externalCashBackService ;
 
    @Autowired
 
    私人 AccountService  帳戶服務 ;
 
    public  void  withdrawMoney（UUID  userId，int  amountOfMoney）{
        synchronized（userId）{  
            結果 result  =  externalCashBackService。evaluateCashBack（userId，amountOfMoney）;
            accountService。轉移（使用者id，amountOfMoney  +  結果。getCashBackAmount（））;
            externalCashBackService。cashBackComplete（使用者id，結果。getCashBackAmount（））;
        }
    }
}
 
 
@服務
公共 類 ExternalCashBackService {
 
    @Autowired
    私人 RestTemplate  restTemplate ;
 
    public  Result  evaluateCashBack（UUID  userId，int  amountOfMoney）{
        return  sendRestRequest（“evaluate”，userId，amountOfMoney）;
    }
 
    public  Result  cashBackComplete（UUID  userId，int  cashBackAmount）{
        return  sendRestRequest（“complete”，userId，cashBackAmount）;
    }
 
    private  Result  sendRestRequest（String  action，UUID  userId，int  value）{
 
        URI  externalCashBackSystemUrl  =
                URI。create（“http://cash-back-system.org/api/”  +  action）;
 
        HttpHeaders  headers  =  new  HttpHeaders（）;
        標題。集（“接受”，的MediaType。APPLICATION_JSON_VALUE）;
        RequestDto  requestDto  =  new  RequestDto（userId，value）;
        HttpEntity <？>  request  =  new  HttpEntity <>（requestDto，headers）;
 
        ResponseDto  responseDto  =  restTemplate。exchange（externalCashBackSystemUrl，
                                                        HttpMethod。GET，
                                                        要求，
                                                        ResponseDto。課程）
                                              。getBody（）;  
 
        返回 新的 結果（responseDto。的getStatus（），responseDto。的getValue（））;
    }
}
 
@服務
公共 類 AccountService {
 
    @Autowired
    private  AccountRepository  accountRepository ;
 
    @Transactional（隔離 =  REPEATABLE_READ）  
    public  void  transfer（UUID  userId，int  amountOfMoney）{
        帳戶 account  =  accountRepository。getOne（userId）;
        帳戶。的setBalance（帳戶。所以getBalance（）-  amountOfMoney）;
        accountRepository。儲存（帳戶）;
    }
}

 

但是，您可以擁有多個具有相同值的物件（userId 在此示例中），但同步適用於物件的例項而不是其值。

下面的程式碼不能很好地工作。因為它不正確同步; 靜態工廠方法UUID.fromString(..)在每次呼叫時都會生成UUID類的新例項，即使您傳遞了相等的字串引數。

因此，我們得到UUID了相同鍵的不同例項。如果我們從多個執行緒執行此程式碼，那麼我們很有可能遇到同步問題：

public  void  threadA（）{
  paymentService。方法withdrawMoney（UUID。fromString（“ea051187-bb4b-4b07-9150-700000000000” ），1000）;
}
 
public  void  threadB（）{
  paymentService。方法withdrawMoney（UUID。fromString（“ea051187-bb4b-4b07-9150-700000000000” ），5000）;
}

 

在這種情況下，您需要為equals物件獲取相同的引用以在其上進行同步。

解決這個問題的錯誤方法

同步方法

你可以移動synchronized一個方法：

public  synchronized  void  withdrawMoney（UUID  userId，int  amountOfMoney）{
    ..
}

 

該解決方案效能不佳。您將阻止絕對所有使用者的資金轉賬。如果您需要使用相同的金鑰同步不同類中的不同操作，則此解決方案根本不會對您有所幫助。

字串實習生

為了確保包含使用者ID的類的例項在所有同步塊中都是相同的，我們可以將它序列化為String並使用它String.intern()來獲取equals字串的相同連結。

String.intern使用全域性池來儲存被攔截的字串。當您在字串上請求實習生時，如果此類字串存在，則從此池中獲取引用，否則此字串將放入池中。

您可以String.intern在The Java Language Specification - 3.10.5 String Literals或有關String.intern的Oracle Java文件中找到更多詳細資訊。

public  void  withdrawMoney（UUID  userId，int  amountOfMoney）{
  同步（使用者id。的toString（）。實習生（））{
      ..
  }
}

 

使用實習生不是一個好習慣，因為使用GC很難清理字串池。並且，您的應用程式可以通過主動使用來消耗太多資源  String.intern。

此外，外部程式碼有可能在與應用程式相同的字串例項上同步。這可能導致死鎖。

一般來說，實習生的使用最好留給JDK的內部庫; Aleksey Shipilev有關於這個概念的好文章。

我們如何才能正確解決這個問題？

建立自己的同步原語

我們需要實現描述下一個圖的行為：

diag 0672834a7737bb323990aabe3bcb5ce6

首先，我們需要建立一個新的同步原語 - 自定義互斥鎖。這將由變數的值起作用，而不是由物件的引用起作用。

它會像一個“命名的互斥體，”  但有點寬，與使用任何物品的價值鑑定，而不僅僅是一個字串的值的能力。您可以找到同步原語的示例，以便通過其他語言（C ++，C＃）中的名稱進行鎖定。現在，我們將用Java解決這個問題。

解決方案看起來像這樣：

public  void  withdrawMoney（UUID  userId，int  amountOfMoney）{
  同步（XMutex。的（使用者id））{
      ..
  }
}

 

為了確保獲得相同的變數值相同的互斥鎖，我們將建立互斥鎖工廠。

public  void  withdrawMoney（UUID  userId，int  amountOfMoney）{
  同步（XMutexFactory。得到（使用者id））{
      ..
  }
}
 
public  void  purchase（UUID  userId，int  amountOfMoney，VendorDescription  供應商）{
  同步（XMutexFactory。得到（使用者id））{
      ..
  }
}

 

為了使用相等的鍵在每個請求上返回相同的互斥鎖例項，我們需要儲存建立的互斥鎖。如果我們將這些互斥鎖儲存在簡單中HashMap，那麼當新鍵出現時，地圖的大小將會增加。我們沒有工具來評估互斥鎖在任何地方都沒有使用的時間。

在這種情況下，我們可以使用它WeakReference來儲存地圖中互斥鎖的引用，就在它使用時。為了實現這種行為，我們可以使用WeakHashMap資料結構。幾個月前我寫了一篇關於這類參考文章的文章; 你可以在這裡更詳細地考慮它：Java中的Soft，Weak，Phantom References

我們的互斥工廠將以此為基礎WeakHashMap。互斥鎖工廠會建立一個新的互斥鎖，如果value(key) 找不到  互斥鎖的話  HashMap。然後，將建立的互斥鎖新增到  HashMap。使用它WeakHashMap允許我們HashMap 在存在任何對它的任何引用的同時儲存互斥  。並且，HashMap 當釋放所有對它的引用時，互斥鎖將自動從中刪除  。

我們需要使用同步版本WeakHashMap; 讓我們看看文件中描述的內容：

此類未同步。可以構造同步的WeakHashMap
使用Collections.synchronizedMap方法。

 

這很難過，不久之後，我們會仔細研究一下原因。但是現在，讓我們考慮一下實現的例子，這是官方文件提出的（我的意思是使用   Collections.synchronizedMap）：

public  final  Map < XMutex < KeyT >，WeakReference < XMutex < KeyT >>>  weakHashMap  =
    收藏。synchronizedMap（new  WeakHashMap < XMutex < KeyT >，
                                                WeakReference < XMutex < KeyT >>>（））;
 
public  XMutex < KeyT >  getMutex（KeyT  key）{
    validateKey（key）;
    return  getExist（key）
            。orElseGet（（）- >  saveNewReference（key））;
}
 
private  可選< XMutex < KeyT >>  getExist（KeyT  key）{
    return  可選。ofNullable（WeakHashMap中，得到（XMutex。的（關鍵）））
                   。map（WeakReference :: get）;
}
 
private  XMutex < KeyT >  saveNewReference（KeyT  key）{
 
    XMutex < KeyT >  互斥鎖 =  XMutex。的（鍵）;
 
    WeakReference < XMutex < KeyT >>  res  =  weakHashMap。put（互斥，新的 WeakReference <>（互斥））;
    如果（RES  ！=  空 &&  資源。獲得（）！=  空）{
        返回 資源。get（）;
    }
    返回 互斥 ;
}

 

效能怎麼樣？

如果我們檢視程式碼Collections.synchronizedMap，那麼我們會在全域性互斥上找到很多同步，這是與SynchronizedMap 例項配對建立的  。

SynchronizedMap（Map < K，V >  m）{
    這個。m  =  物體。requireNonNull（m）;
    互斥 =  這個 ;   
}

 

並且所有其他方法  SynchronizedMap 都在互斥鎖上同步：

public  int  size（）{
    synchronized（互斥）{ return  m。size（）;}
}
public  boolean  containsKey（Object  key）{
    synchronized（互斥）{ return  m。containsKey（key）;}
}
public  V  get（Object  key）{
    synchronized（互斥）{ return  m。得到（關鍵）;}
}
public  V  put（K  鍵，V  值）{
    synchronized（互斥）{ return  m。put（key，value）;}
}
public  V  remove（Object  key）{
    synchronized（互斥）{ return  m。刪除（鍵）;}
}
 
...

 

此解決方案沒有最佳效能。所有這些同步都會導致我們使用互斥鎖工廠對每個操作進行永久鎖定。

將WeakReference作為鍵的ConcurrentHashMap

我們需要看一下使用的ConcurrentHashMap。它具有比Collections.synchronizedMap更好的效能。但我們有一個問題 - ConcurrentHashMap不允許使用弱引用。這意味著垃圾收集器無法刪除未使用的互斥鎖。

我找到了兩種方法來解決這個問題：

  • 首先是建立我自己的ConcurrentMap實現。這是正確的決定，但需要很長時間。
  • 第二個是使用ConcurrentReferenceHashMapSpring Framework 中的實現。這是一個很好的實現，但它有一些細微差別。我們將在下面考慮它們。

讓我們改變  XMutexFactory 實現來使用ConcurrentReferenceHashMap：

公共 類 XMutexFactory < KeyT > {
 
  / **
   *使用預設設定建立互斥鎖工廠
   * /
  public  XMutexFactory（）{
      這個。map  =  new  ConcurrentReferenceHashMap <>（DEFAULT_INITIAL_CAPACITY，
                                                  DEFAULT_LOAD_FACTOR，
                                                  DEFAULT_CONCURRENCY_LEVEL，
                                                  DEFAULT_REFERENCE_TYPE）;
  }
 
  / **
   *通過鍵建立並返回互斥鎖。
   *如果此鍵的互斥鎖已存在於弱對映中，
   *然後返回互斥鎖的相同引用。
   * /
  public  XMutex < KeyT >  getMutex（KeyT  key）{
      歸還 這個。地圖。compute（key，（k，v）- >（v  ==  null）？ new  XMutex <>（k）：v）;
  }
 
}

 

這很酷！

程式碼少，但效能比以前更多。我們試著檢查一下這個解決方案的效能。

建立一個簡單的基準

為了選擇實現，我做了一個小基準測試。

Map 測試中涉及三種實現  ：

  •  Collections.synchronizedMap 基於 WeakHashMap 
  •  ConcurrentHashMap 
  •  ConcurrentReferenceHashMap 

我使用  ConcurrentHashMap in基準測試來比較測量。此實現不適合在互斥鎖的工廠中使用，因為它不支援使用弱引用或軟引用。

所有基準測試都是使用JMH庫編寫的。

＃ 執行 完成。總 時間：00：04：39
 
基準                                   模式     Cnt         評分         誤差   單位
ConcurrentMap。ConcurrentHashMap的            thrpt        5         0，015  ？       0，004   OPS / 納秒
ConcurrentMap。ConcurrentReferenceHashMap    thrpt        5         0，008  ？       0，001   OPS / 納秒
ConcurrentMap。SynchronizedMap               thrpt        5         0，005  ？       0，001   OPS / 納秒
ConcurrentMap。ConcurrentHashMap的             avgt        5       565，515  ？      23，638    納秒/ 運算
ConcurrentMap。ConcurrentReferenceHashMap     avgt        5      1098，939  ？      28，828    納秒/ 運算
ConcurrentMap。SynchronizedMap                avgt        5      1503，593  ？     150，552    納秒/ 運算
ConcurrentMap。ConcurrentHashMap的           樣品  301796       663，330  ？      11，708    納秒/ 運算
ConcurrentMap。ConcurrentReferenceHashMap   樣品  180062      1110，882  ？       6，928    納秒/ 運算
ConcurrentMap。SynchronizedMap              樣品  136290      1465，543  ？       5，150    納秒/ 運算
ConcurrentMap。的ConcurrentHashMap                SS        5    336419，150  ？  617549，053    納秒/ 運算
ConcurrentMap。ConcurrentReferenceHashMap       SS        5    922844，750  ？  468380，489    納秒/ 運算
ConcurrentMap。SynchronizedMap                  SS        5   1199159，700  ？ 4339391，394    納秒/ 運算

 

在這個微基準測試中，我建立了一個情況，當幾個執行緒計算地圖中的值。您可以在Concurrent Map基準測試中更詳細地考慮此基準測試的原始碼 

把它放在圖表上：

基準結果

因此，ConcurrentReferenceHashMap 在這種情況下使用它是  正確的。

XSync庫入門

我將此程式碼打包到XSync庫中，您可以將其用作變數值同步的現成解決方案。

為此，您需要新增下一個依賴項：

< 依賴>
  < groupId > com.antkorwin </ groupId >
  < artifactId > xsync </ artifactId >
  < version > 1.1 </ version >
</ dependency >

 

然後，您可以建立XSync類的例項，以便在需要的型別上進行同步。對於Spring Framework，您可以將它們作為bean：

@豆
public  XSync < UUID >  xSync（）{
    返回 新的 XSync <>（）;
}

 

現在，您可以使用它：

@Autowired
私有 XSync < UUID >  xSync ;
 
public  void  withdrawMoney（UUID  userId，int  amountOfMoney）{
  xSync。execute（userId，（）- > {
      結果 result  =  externalPolicySystem。validateTransfer（userId，amountOfMoney，WITHDRAW）;
      accountService。轉移（userId，amountOfMoney，WITHDRAW）;
  }）;
}
 
public  void  purchase（UUID  userId，int  amountOfMoney，VendorDescription  供應商）{
  xSync。execute（userId，（）- > {
      ..
  }）;
}

 

併發測試

為了確保這段程式碼執行良好，我寫了幾個併發測試。

有一個這樣的測試的例子：

public  void  testSyncBySingleKeyInConcurrency（）{
   //安排
   XSync < UUID >  xsync  =  new  XSync <>（）;
   String  id  =  UUID。randomUUID（）。toString（）;
   NonAtomicInt  var  =  new  NonAtomicInt（0）;
 
   //這裡有一個魔力： 
   //我們建立了一個並行流並嘗試增加 
   //每個流中的相同非原子整數變數
   IntStream。範圍（0，THREAD_CNT）
            。盒裝（）
            。並行（）
            。的forEach（Ĵ  - >  XSYNC。執行（UUID。fromString（ID），VAR :: 增量））;  
 
   //斷言
   等待（）。atMost（5，TIMEUNIT。SECONDS）
          。直到（var :: getValue，equalTo（THREAD_CNT））;
 
   斷言。assertThat（VAR。的getValue（））。isEqualTo（THREAD_CNT）;
}
 
/ **
 *執行不是執行緒安全的整數變數：
 * /
@Getter
@AllArgsConstructor
私有 類 NonAtomicInt {  
    私有 int  值 ;
 
    public  int  increment（）{
        返回 值++ ;
    }
}

 

讓我們看看這個測試的結果：

併發測試結果

相關推薦

如何通過Java中的物件值來同步塊

問題 有時，我們需要通過變數的值來同步程式碼塊。 為了解這個問題，我們將考慮一個簡單的銀行應用程式，它對客戶的每次轉賬進行以下操作： 通過此外部Web服務轉移評估現金返還金額（CashBackService） 在資料庫中執行匯款（AccountService） 更新現金

用畫小狗的方法來解釋Java中的值傳遞

java 一次 虛擬機 mage 新的 不難 修改 相同 完整 在開始看我畫小狗之前，咱們先來看道很簡單的題目： 下面程序的輸出是什麽？ Dog myDog = new Dog("旺財"); changeName(myDog); System.out.println(

java jdbc ResultSet結果通過java反射賦值給java物件

在不整合框架的情況下，使用jdbc從資料庫讀取資料時都得一個個的get和set，不僅累程式碼還顯得不簡潔，所以利用java的反射機制寫了一個工具類，這樣用jdbc從資料庫拿資料的時候就不用那麼麻煩了。 因為很多情況下資料不止一條，所以返回的是物件類的一個集合。 需要注意的地方：在這裡，資料庫欄位命名格式為

JAVA中物件的賦值與引用

前言 最近在學習紅黑樹，當我嘗試不使用遞迴來實現時，發現自己的大腦陷入了混亂。 究其原因，是對JAVA中的基本型別和引用型別有所誤解。 特地重新搜尋+實踐一番，漲個姿勢。 一番折騰 先找個物件過年 class Node {

JAVA中只有值傳遞

http 自己的 分享 傳遞 uil string 論戰 顯示 主函數 今天，我在一本面試書上看到了關於java的一個參數傳遞的問題： 寫道 java中對象作為參數傳遞給一個方法，到底是值傳遞，還是引用傳遞？ 我毫無疑問的回答：“引用傳遞！”，並且還覺得自己對java的這

JAVA中的值傳遞和引用傳遞問題

log 輸出結果 基礎知識 blue static 繼續 oid .net red 　　這是個老生常談的問題了，引起過無數爭論，但可以說一直沒有一個令人滿意的回答。 　　有人總結過： 對象是按引用傳遞的 Java 應用程序有且僅有的一種參數傳遞機制，即按值傳遞

通過js中的useragrent來判斷設備是pc端還是移動端，跳轉不同的地址

lenovo err agent indexof pad ren phi mobile 手機 if(/AppleWebKit.*Mobile/i.test(navigator.userAgent) || (/MIDP|SymbianOS|NOKIA|SAMSUNG|L

為什麽說Java中只有值傳遞----說服自己

width new 外部變量 Go sch -- 而不是 得到 cdp 在開始深入講解之前，有必要糾正一下大家以前的那些錯誤看法了。如果你有以下想法，那麽你有必要好好閱讀本文。 錯誤理解一：值傳遞和引用傳遞，區分的條件是傳遞的內容，如果是個值，就是值傳遞。如果是個引用，

java中的值傳遞和引用傳遞

raise 兩個 demo1 double class turn style chan reference java 參數，不管是原始類型還是引用類型，傳遞的都是參數的副本。 如果參數類型是原始類型，那麽傳遞的參數是這個參數的一個副本，也就是這個原始參數的值。如果在函數中改

如何理解IEEE 754標準對Java中float值和double值的規定

rac tro zh-cn 分享圖片 編號 如何 ins font 指數 在Java語言中，我們可以使用float和double這兩種基本數據類型來表示特定的數據。 這兩種數據類型，本質上是浮點數（floating-point number），浮點是一種對於實數的近似值數值

JAVA中只有值傳遞（用內存理解）

合並 形參 java 註意 拷貝 引用數據類型 基本類 壓棧 數據 剛剛上路的小夥盤們牢記哦，JAVA只有值傳遞，八大基本類型傳遞的是值。所有當調用帶有基本類型參數的方法時會把這個方法和他的局部變量一起合並成棧幀然後壓棧，註意方法的參數也是這個方法的局部變量，所以當實參將值

Java中返回值的詳解

package text 希望 得到 輸出 turn void 方法 dem package com.company; //java中main()函數中調用其他方法的兩種方式//1.實例化對象 public class returnDemo { public s

java中物件和物件引用的區別

1.何謂物件？ 　　在Java中有一句比較流行的話，叫做“萬物皆物件”，這是Java語言設計之初的理念之一。要理解什麼是物件，需要跟類一起結合起來理解。下面這段話引自《Java程式設計思想》中的一段原話： 　　“按照通俗的說法，每個物件都是某個類（class）的一個例項（instance），這裡，‘

Java中物件的this引用

        Java提供了一個this關鍵字，this關鍵字總是指向呼叫該方法的物件。根據this出現位置的不同，this作為物件的預設引用有兩種情形。 -構造器中引用該構造器正在初始化的物件 -在方法中引用呼叫該方法的物件   &n

優先順序PK：Java中的4種程式碼塊，誰先誰後？

問題：Java裡的四種程式碼塊，像積木一般搭成程式碼塔。那麼一段複雜的程式碼在JVM裡每一句的執行順序是如何的呢？ 思路：看程式碼塊的優先順序順序——>被呼叫的順序 答：要回答這個問題，我們先來看看四種程式碼塊是哪些： 有了定義，還是要具體例子的： public cl

Java中物件的初始化過程詳解

在Java中，我們需要對物件進行初始化操作。 經常需要new 物件。但是new物件時到底發生了什麼呢？ 有時候我們不是特別清晰。 所以今天又重新學習了一下JavaSE部分，又有了新的感受。 在此記錄一下 首先程式碼部分 Person類： class Person{

Java中的值傳遞和"引用"傳遞

引言 學習過C語言的同學都很清楚在c中呼叫方法的引數有值傳遞和引用傳遞兩種方式。關於值傳遞和引用傳遞網上有許多的部落格寫的很好，這裡我就不解釋了。附上一篇:值傳遞和引用傳遞。但是使用過Java的同學可能知道，如果我們按照C語言的引數傳遞方式來理解Java中引數傳遞的話，有時候可能會和自己預料的答案有所出入。

Java中物件和json互相轉換的工具類

package com.Dingyu.util; import java.util.List; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.JavaT

Java中執行緒的同步非同步、以及執行緒的安全

  什麼是執行緒同步？     這裡的“同”是協同的意思，並不是共同。那麼就很好理解同步了，就是一起操作但並不是同時操作。比如流水線組裝汽車，可以視作一個執行緒，只有裝好了上一步的門，才可以裝下一步的門窗玻璃。沒有裝門能裝上玻璃嗎？顯然不行。所以執

java中物件可以存在記憶體中哪些地方

注意：以下都是個人理解。如有不同之處，望提出（-_-）。 java中識別符號對應的值可以改變的叫做變數，不可以改變的叫做常量。如： //識別符號a的值可以改變，叫做變數 int a=3; a=4; //識別符號b的值不可以改變，叫做常量 final int b=3;