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

1次訂單事故，扣了我3個月績效！

作者：funnyZpC
開發 前端 開發工具
去年年底的時候，我們線上出了一次事故。

 [[388607]] 

圖片來自 Pexels

這個事故的表象是這樣的：系統出現了兩個一模一樣的訂單號，訂單的內容卻不是不一樣的，而且系統在按照訂單號查詢的時候一直拋錯，也沒法正常回調，而且事情發生的不止一次，所以 這次系統升級一定要解決掉。

經手的同事之前也改過幾次，不過效果始終不好：總會出現訂單號重復的問題， 所以趁著這次問題我好好的理了一下我同事寫的代碼。

這里簡要展示下當時的代碼：

  1. /** 
  2.      * OD單號生成 
  3.      * 訂單號生成規則：OD + yyMMddHHmmssSSS + 5位數(商戶ID3位+隨機數2位) 22位 
  4.      */ 
  5.     public static String getYYMMDDHHNumber(String merchId){ 
  6.         StringBuffer orderNo = new StringBuffer(new SimpleDateFormat("yyMMddHHmmssSSS").format(new Date())); 
  7.         if(StringUtils.isNotBlank(merchId)){ 
  8.             if(merchId.length()>3){ 
  9.                 orderNo.append(merchId.substring(0,3)); 
  10.             }else { 
  11.                 orderNo.append(merchId); 
  12.             } 
  13.         } 
  14.         int orderLength = orderNo.toString().length(); 
  15.         String randomNum = getRandomByLength(20-orderLength); 
  16.         orderNo.append(randomNum); 
  17.         return orderNo.toString(); 
  18.     } 
  19.  
  20.  
  21.     /** 生成指定位數的隨機數 **/ 
  22.     public static String getRandomByLength(int size){ 
  23.         if(size>8 || size<1){ 
  24.             return ""; 
  25.         } 
  26.         Random ne = new Random(); 
  27.         StringBuffer endNumStr = new StringBuffer("1"); 
  28.         StringBuffer staNumStr = new StringBuffer("9"); 
  29.         for(int i=1;i<size;i++){ 
  30.             endNumStr.append("0"); 
  31.             staNumStr.append("0"); 
  32.         } 
  33.         int randomNum = ne.nextInt(Integer.valueOf(staNumStr.toString()))+Integer.valueOf(endNumStr.toString()); 
  34.         return String.valueOf(randomNum); 
  35.     } 

可以看到，這段代碼寫的其實不怎么好，代碼部分暫且不議，代碼中使訂單號不重復的主要因素點是隨機數和毫秒，可是這里的隨機數只有兩位。

在高并發環境下極容易出現重復問題，同時毫秒這一選擇也不是很好，在多核 CPU 多線程下，一定時間內(極小的)這個毫秒可以說是固定不變的(測試驗證過)。

所以這里我先以 100 個并發測試下這個訂單號生成，關注微信訂閱號碼匠筆記，回復架構獲取一些列的架構知識。

測試代碼如下：

  1. public static void main(String[] args) { 
  2.         final String merchId = "12334"; 
  3.         List<String> orderNos = Collections.synchronizedList(new ArrayList<String>()); 
  4.         IntStream.range(0,100).parallel().forEach(i->{ 
  5.             orderNos.add(getYYMMDDHHNumber(merchId)); 
  6.         }); 
  7.  
  8.         List<String> filterOrderNos = orderNos.stream().distinct().collect(Collectors.toList()); 
  9.  
  10.         System.out.println("生成訂單數："+orderNos.size()); 
  11.         System.out.println("過濾重復后訂單數："+filterOrderNos.size()); 
  12.         System.out.println("重復訂單數："+(orderNos.size()-filterOrderNos.size())); 
  13.     } 

果然，測試的結果如下：

  1. 生成訂單數：100 
  2. 過濾重復后訂單數：87 
  3. 重復訂單數：13 

生成訂單數：100過濾重復后訂單數：87重復訂單數：13

當時我就震驚了，一百個并發里面竟然有 13 個重復的!!!我趕緊讓同事先不要發版，這活兒我接了!

對這一燙手的山竽拿到手里沒有一個清晰的解決方案可是不行的，我大概花了 6 分多鐘和同事商量了下業務場景。

最后決定做如下更改：

  • 去掉商戶 ID 的傳入(按同事的說法，傳入商戶 ID 也是為了防止重復訂單的，事實證明并沒有叼用)
  • 毫秒僅保留三位(縮減長度同時保證應用切換不存在重復的可能)
  • 使用線程安全的計數器做數字遞增(三位數最低保證并發 800 不重復，代碼中我給了 4 位)
  • 更換日期轉換為 java8 的日期類以格式化(線程安全及代碼簡潔性考量)

經過以上思考后我的最終代碼是：

  1. /** 訂單號生成(NEW) **/ 
  2.    private static final AtomicInteger SEQ = new AtomicInteger(1000); 
  3.    private static final DateTimeFormatter DF_FMT_PREFIX = DateTimeFormatter.ofPattern("yyMMddHHmmssSS"); 
  4.    private static ZoneId ZONE_ID = ZoneId.of("Asia/Shanghai"); 
  5.    public static String generateOrderNo(){ 
  6.        LocalDateTime dataTime = LocalDateTime.now(ZONE_ID); 
  7.        if(SEQ.intValue()>9990){ 
  8.            SEQ.getAndSet(1000); 
  9.        } 
  10.        return  dataTime.format(DF_FMT_PREFIX)+SEQ.getAndIncrement(); 
  11.    } 

當然代碼寫完成了可不能這么隨隨便便結束了，現在得走一個測試 main 函數看看：

  1. public static void main(String[] args) { 
  2.  
  3.     List<String> orderNos = Collections.synchronizedList(new ArrayList<String>()); 
  4.     IntStream.range(0,8000).parallel().forEach(i->{ 
  5.         orderNos.add(generateOrderNo()); 
  6.     }); 
  7.  
  8.     List<String> filterOrderNos = orderNos.stream().distinct().collect(Collectors.toList()); 
  9.  
  10.     System.out.println("生成訂單數："+orderNos.size()); 
  11.     System.out.println("過濾重復后訂單數："+filterOrderNos.size()); 
  12.     System.out.println("重復訂單數："+(orderNos.size()-filterOrderNos.size())); 
  13. } 
  14.  
  15. /** 
  16.     測試結果：  
  17.     生成訂單數：8000 
  18.     過濾重復后訂單數：8000 
  19.     重復訂單數：0 
  20. **/ 

真好，一次就成功了，可以直接上線了。。。

然而，我回過頭來看以上代碼，雖然最大程度解決了并發單號重復的問題，不過對于我們的系統架構還是有一個潛在的隱患。

如果當前應用有多個實例(集群)難道就沒有重復的可能了?鑒于此問題就必然需要一個有效的解決方案，所以這時我就思考：多個實例應用訂單號如何區分開呢?

以下為我思考的大致方向：

  • 使用 UUID(在第一次生成訂單號時初始化一個)
  • 使用 Redis 記錄一個增長 ID
  • 使用數據庫表維護一個增長 ID
  • 應用所在的網絡 IP
  • 應用所在的端口號
  • 使用第三方算法(雪花算法等等)
  • 使用進程 ID(某種程度下是一個可行的方案)

在此我想了下，我們的應用是跑在 Docker 里面，而且每個 Docker 容器內的應用端口都一樣，不過網路 IP 不會存在重復的問題，至于進程也有存在重復的可能，對于 UUID 的方式之前吃過虧。

總之吧，Redis 或 DB 也算是一種比較好的方式，不過獨立性較差。。。

同時還有一個因素也很重要，就是所有涉及到訂單號生成的應用都是在同一臺宿主機(Linux 實體服務器)上， 所以就目前的系統架構我選用了 IP 的方式。

以下是我的代碼：

  1. import org.apache.commons.lang3.RandomUtils; 
  2.  
  3. import java.net.InetAddress; 
  4. import java.time.LocalDateTime; 
  5. import java.time.ZoneId; 
  6. import java.time.format.DateTimeFormatter; 
  7. import java.util.ArrayList; 
  8. import java.util.Collections; 
  9. import java.util.List; 
  10. import java.util.concurrent.atomic.AtomicInteger; 
  11. import java.util.stream.Collectors; 
  12. import java.util.stream.IntStream; 
  13.  
  14. public class OrderGen2Test { 
  15.  
  16.     /** 訂單號生成 **/ 
  17.     private static ZoneId ZONE_ID = ZoneId.of("Asia/Shanghai"); 
  18.     private static final AtomicInteger SEQ = new AtomicInteger(1000); 
  19.     private static final DateTimeFormatter DF_FMT_PREFIX = DateTimeFormatter.ofPattern("yyMMddHHmmssSS"); 
  20.     public static String generateOrderNo(){ 
  21.         LocalDateTime dataTime = LocalDateTime.now(ZONE_ID); 
  22.         if(SEQ.intValue()>9990){ 
  23.             SEQ.getAndSet(1000); 
  24.         } 
  25.         return  dataTime.format(DF_FMT_PREFIX)+ getLocalIpSuffix()+SEQ.getAndIncrement(); 
  26.     } 
  27.  
  28.     private volatile static String IP_SUFFIX = null; 
  29.     private static String getLocalIpSuffix (){ 
  30.         if(null != IP_SUFFIX){ 
  31.             return IP_SUFFIX; 
  32.         } 
  33.         try { 
  34.             synchronized (OrderGen2Test.class){ 
  35.                 if(null != IP_SUFFIX){ 
  36.                     return IP_SUFFIX; 
  37.                 } 
  38.                 InetAddress addr = InetAddress.getLocalHost(); 
  39.                 //  172.17.0.4  172.17.0.199 , 
  40.                 String hostAddress = addr.getHostAddress(); 
  41.                 if (null != hostAddress && hostAddress.length() > 4) { 
  42.                     String ipSuffix = hostAddress.trim().split("\\.")[3]; 
  43.                     if (ipSuffix.length() == 2) { 
  44.                         IP_SUFFIX = ipSuffix; 
  45.                         return IP_SUFFIX; 
  46.                     } 
  47.                     ipSuffix = "0" + ipSuffix; 
  48.                     IP_SUFFIX = ipSuffix.substring(ipSuffix.length() - 2); 
  49.                     return IP_SUFFIX; 
  50.                 } 
  51.                 IP_SUFFIX = RandomUtils.nextInt(10, 20) + ""; 
  52.                 return IP_SUFFIX; 
  53.             } 
  54.         }catch (Exception e){ 
  55.             System.out.println("獲取IP失敗:"+e.getMessage()); 
  56.             IP_SUFFIX =  RandomUtils.nextInt(10,20)+""; 
  57.             return IP_SUFFIX; 
  58.         } 
  59.     } 
  60.  
  61.  
  62.     public static void main(String[] args) { 
  63.         List<String> orderNos = Collections.synchronizedList(new ArrayList<String>()); 
  64.         IntStream.range(0,8000).parallel().forEach(i->{ 
  65.             orderNos.add(generateOrderNo()); 
  66.         }); 
  67.  
  68.         List<String> filterOrderNos = orderNos.stream().distinct().collect(Collectors.toList()); 
  69.  
  70.         System.out.println("訂單樣例："+ orderNos.get(22)); 
  71.         System.out.println("生成訂單數："+orderNos.size()); 
  72.         System.out.println("過濾重復后訂單數："+filterOrderNos.size()); 
  73.         System.out.println("重復訂單數："+(orderNos.size()-filterOrderNos.size())); 
  74.     } 
  75. } 
  76.  
  77. /** 
  78.   訂單樣例：20082115575546011022 
  79.   生成訂單數：8000 
  80.   過濾重復后訂單數：8000 
  81.   重復訂單數：0 
  82. **/ 

最后，代碼說明及幾點建議：

  • generateOrderNo() 方法內不需要加鎖，因為 AtomicInteger 內使用的是 CAS 自旋轉鎖(保證可見性的同時也保證原子性，具體的請自行了解)
  • getLocalIpSuffix() 方法內不需要對不為 null 的邏輯加同步鎖(雙向校驗鎖，整體是一種安全的單例模式)
  • 本人實現的方式并不是解決問題的唯一方式，具體解決問題需要視當前系統架構具體而論
  • 任何測試都是必要的，我同事在前幾次嘗試解決這個問題后都沒有自測，不測試有損開發專業性!

作者：funnyZpC

編輯：陶家龍

出處：cnblogs.com/funnyzpc/p/13541713.html

 

責任編輯：武曉燕 來源： 博客園
訂單事故系統
相關推薦

2022-10-17 08:31:03

生產環境P0項目

2020-10-21 12:10:30

訂單號Java代碼

2018-02-06 15:15:16

程序員年終獎

2013-07-18 10:03:06

TypeScript

2023-06-09 16:50:21

Tigerbo

2009-02-09 09:14:06

北電破產保護例行延長

2018-12-18 09:45:51

5G4G通信網絡

2017-10-31 08:52:43

數據驅動效率

2023-07-04 07:12:31

Intel傲騰內存

2023-01-16 14:49:00

MongoDB數據庫

2022-07-11 13:58:14

數據庫業務流程系統

2009-09-02 08:44:30

2020-10-23 10:53:06

iPhone 12蘋果降價

2021-12-28 22:09:59

5G核心網公有云

2021-12-28 06:55:09

事故訂單號績效

2022-09-07 09:09:13

高并發架構

2014-07-21 15:37:19

互聯網跳槽調查

2011-12-06 22:05:40

憤怒的小鳥

2024-09-09 14:15:00

AI訓練

2020-11-13 11:01:33

工具人互聯網技術
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 精品免费 | 久久99国产精一区二区三区 | 在线观看中文字幕 | 污片在线免费观看 | 日韩在线观看一区 | 九色 在线 | 久久久久久久久国产 | 精品国产一区二区三区日日嗨 | 国产精品久久久久久久久久久久 | 在线一区二区三区 | www,黄色,com| 91香蕉视频在线观看 | 久在线精品视频 | 日韩视频在线一区 | 黄色片视频网站 | 爱爱爱av| 日韩欧美亚洲综合 | 国产激情偷乱视频一区二区三区 | 国产精品毛片一区二区三区 | 中文字幕一区二区三区在线观看 | 国产电影一区二区三区爱妃记 | 精品久久久网站 | 久久久国产精品视频 | 国产精品视频在线播放 | 亚洲国产一区二区三区在线观看 | 国产视频在线一区二区 | 亚洲欧美日韩一区二区 | 一区二区视频 | 欧美日韩精品 | 青青草在线播放 | 日韩亚洲一区二区 | 久久精品国产一区 | 天天夜干 | 一区二区三区亚洲视频 | 特黄色一级毛片 | 国产黄色在线观看 | 热久久性| 精品国产乱码久久久久久牛牛 | 亚洲精品成人在线 | 国产精品美女久久久久久不卡 | 国产第一页在线播放 |