2. 程式人生 > >非同步化，高併發大殺器

非同步化，高併發大殺器

阿新 • • 發佈：2018-12-10

聊聊如何讓專案非同步化的一些事。

1.同步和非同步，阻塞和非阻塞

同步和非同步，阻塞和非阻塞, 這個幾個詞已經是老生常談，當時常常還是有很多同學分不清楚，以為同步肯定就是阻塞，非同步肯定就是非阻塞，其他他們不是一回事。

同步和非同步關注的是結果訊息的通訊機制

  • 同步:同步的意思就是呼叫方需要主動等待結果的返回

  • 非同步:非同步的意思就是不需要主動等待結果的返回，而是通過其他手段比如，狀態通知，回撥函式等。

阻塞和非阻塞主要關注的是等待結果返回呼叫方的狀態

  • 阻塞:是指結果返回之前，當前執行緒被掛起，不做任何事

  • 非阻塞:是指結果在返回之前，執行緒可以做一些其他事，不會被掛起。

可以看見同步和非同步，阻塞和非阻塞主要關注的點不同，有人會問同步還能非阻塞，非同步還能阻塞？當然是可以的，下面為了更好的說明他們的組合之間的意思，用幾個簡單的例子說明: 1.同步阻塞:同步阻塞基本也是程式設計中最常見的模型，打個比方你去商店買衣服，你去了之後發現衣服賣完了，那你就在店裡面一直等，期間不做任何事(包括看手機)，等著商家進貨，直到有貨為止，這個效率很低。

2.同步非阻塞:同步非阻塞在程式設計中可以抽象為一個輪詢模式，你去了商店之後，發現衣服賣完了，這個時候不需要傻傻的等著，你可以去其他地方比如奶茶店，買杯水，但是你還是需要時不時的去商店問老闆新衣服到了嗎。

3.非同步阻塞:非同步阻塞這個程式設計裡面用的較少，有點類似你寫了個執行緒池,submit然後馬上future.get()，這樣執行緒其實還是掛起的。有點像你去商店買衣服，這個時候發現衣服沒有了，這個時候你就給老闆留給電話，說衣服到了就給我打電話，然後你就守著這個電話，一直等著他響什麼事也不做。這樣感覺的確有點傻，所以這個模式用得比較少。

4.非同步非阻塞:非同步非阻塞這也是現在高併發程式設計的一個核心，也是今天主要講的一個核心。好比你去商店買衣服，衣服沒了，你只需要給老闆說這是我的電話，衣服到了就打。然後你就隨心所欲的去玩，也不用操心衣服什麼時候到，衣服一到，電話一響就可以去買衣服了。

2.同步阻塞 PK 非同步非阻塞

上面已經看到了同步阻塞的效率是多麼的低，如果使用同步阻塞的方式去買衣服，你有可能一天只能買一件衣服，其他什麼事都不能幹，如果用非同步非阻塞的方式去買，買衣服只是你一天中進行的一個小事。

我們把這個對映到我們程式碼中，當我們的執行緒發生一次rpc呼叫或者http呼叫，又或者其他的一些耗時的IO呼叫，發起之後，如果是同步阻塞，我們的這個執行緒就會被阻塞掛起，直到結果返回，試想一下如果IO呼叫很頻繁那我們的CPU使用率其實是很低很低。正所謂是物盡其用，既然CPU的使用率被IO呼叫搞得很低，那我們就可以使用非同步非阻塞，當發生IO呼叫時我並不馬上關心結果，我只需要把回撥函式寫入這次IO呼叫，我這個時候執行緒可以繼續處理新的請求，當IO呼叫結束結束時，會呼叫回撥函式。而我們的執行緒始終處於忙碌之中，這樣就能做更多的有意義的事了。

這裡首先要說明的是，非同步化不是萬能，非同步化並不能縮短你整個鏈路呼叫時間長的問題，但是他能極大的提升你的最大qps。一般我們的業務中有兩處比較耗時:

  • cpu: cpu耗時指的是我們的一般的業務處理邏輯，比如一些資料的運算，物件的序列化。這些非同步化是不能解決的，得需要靠一些演算法的優化，或者一些高效能框架。

  • iowait: io耗時就像我們上面說的,一般發生在網路呼叫，檔案傳輸中等等，這個時候執行緒一般會掛起阻塞。而我們的非同步化通常用於解決這部分的問題。

3.哪些可以非同步化？

上面說了非同步化是用於解決IO阻塞的問題，而我們一般專案中可以使用非同步化如下:

  • servlet非同步化,springmvc非同步化

  • rpc呼叫如(dubbo,thrift),http呼叫非同步化

  • 資料庫呼叫，快取呼叫非同步化

下面我會從上面幾個方面進行非同步化的介紹.

4.servlet非同步化

對於Java開發程式設計師來說servlet並不陌生吧，在專案中不論你使用struts2,還是使用的springmvc,本質上都是封裝的servlet。但是我們的一般的開發，其實都是使用的同步阻塞模式如下:

如Java工程化、高效能及分散式、高效能、深入淺出。高架構。效能調優、Spring，MyBatis，Netty原始碼分析和大資料等多個知識點。如果你想拿高薪的，想學習的，想就業前景好的，想跟別人競爭能取得優勢的，想進阿里面試但擔心面試不過的，你都可以來，q群號為：856443934 

上面的模式優點在於編碼簡單，適合在專案啟動初期，訪問量較少，或者是CPU運算較多的專案

缺點在於，業務邏輯執行緒和servlet容器執行緒是同一個，一般的業務邏輯總得發生點IO，比如查詢資料庫，比如產生RPC呼叫，這個時候就會發生阻塞，而我們的servlet容器執行緒肯定是有限的，當servlet容器執行緒都被阻塞的時候我們的服務這個時候就會發生拒絕訪問，執行緒不然我當然們可以通過增加機器的一系列手段來解決這個問題，但是俗話說得好靠人不如靠自己，靠別人替我分擔請求，還不如我自己搞定。所以在servlet3.0之後支援了非同步化，我們採用非同步化之後就會變成如下: 

如Java工程化、高效能及分散式、高效能、深入淺出。高架構。效能調優、Spring，MyBatis，Netty原始碼分析和大資料等多個知識點。如果你想拿高薪的，想學習的，想就業前景好的，想跟別人競爭能取得優勢的，想進阿里面試但擔心面試不過的，你都可以來，q群號為：856443934

在這裡我們採用新的執行緒處理業務邏輯，IO呼叫的阻塞就不會影響我們的serlvet了，實現非同步serlvet的程式碼也比較簡單,如下:

  1. @WebServlet(name = "WorkServlet",urlPatterns = "/work",asyncSupported =true)

  2. public class WorkServlet extends HttpServlet{

  3.    private static final long serialVersionUID = 1L;

  4.    @Override

  5.    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

  6.        this.doPost(req, resp);

  7.    }

  8.    @Override

  9.    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

  10.        //設定ContentType,關閉快取

  11.        resp.setContentType("text/plain;charset=UTF-8");

  12.        resp.setHeader("Cache-Control","private");

  13.        resp.setHeader("Pragma","no-cache");

  14.        final PrintWriter writer= resp.getWriter();

  15.        writer.println("老師檢查作業了");

  16.        writer.flush();

  17.        List<String> zuoyes=new ArrayList<String>();

  18.        for (int i = 0; i < 10; i++) {

  19.            zuoyes.add("zuoye"+i);;

  20.        }

  21.        //開啟非同步請求

  22.        final AsyncContext ac=req.startAsync();

  23.        doZuoye(ac, zuoyes);

  24.        writer.println("老師佈置作業");

  25.        writer.flush();

  26.    }

  27.    private void doZuoye(final AsyncContext ac, final List<String> zuoyes) {

  28.        ac.setTimeout(1*60*60*1000L);

  29.        ac.start(new Runnable() {

  30.            @Override

  31.            public void run() {

  32.                //通過response獲得字元輸出流

  33.                try {

  34.                    PrintWriter writer=ac.getResponse().getWriter();

  35.                    for (String zuoye:zuoyes) {

  36.                        writer.println("\""+zuoye+"\"請求處理中");

  37.                        Thread.sleep(1*1000L);

  38.                        writer.flush();

  39.                    }

  40.                    ac.complete();

  41.                } catch (Exception e) {

  42.                    e.printStackTrace();

  43.                }

  44.            }

  45.        });

  46.    }

  47. }

實現serlvet的關鍵在於http採取了長連線，也就是當請求打過來的時候就算有返回也不會關閉，因為可能還會有資料，直到返回關閉指令。 AsyncContext ac=req.startAsync(); 用於獲取非同步上下文，後續我們通過這個非同步上下文進行回撥返回資料，有點像我們買衣服的時候，給老闆一個電話，而這個上下文也是一個電話，當有衣服到的時候，也就是當有資料準備好的時候就可以打電話傳送資料了。 ac.complete(); 用來進行長連結的關閉。

## 4.1springmvc非同步化 現在其實很少人來進行serlvet程式設計，都是直接採用現成的一些框架，比如struts2，springmvc。下面介紹下使用springmvc如何進行非同步化:

  • 首先確認你的專案中的Servlet是3.0以上的！！，其次springMVC4.0+

  1. <dependency>

  2.      <groupId>javax.servlet</groupId>

  3.      <artifactId>javax.servlet-api</artifactId>

  4.      <version>3.1.0</version>

  5.      <scope>provided</scope>

  6.    </dependency>

  7.    <dependency>

  8.      <groupId>org.springframework</groupId>

  9.      <artifactId>spring-webmvc</artifactId>

  10.      <version>4.2.3.RELEASE</version>

  11.    </dependency>

  • web.xml頭部宣告，必須要3.0,filter和serverlet設定為非同步

  1. <?xml version="1.0" encoding="UTF-8"?>

  2. <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"

  3.    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  4.    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

  5.    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  6.    <filter>

  7.        <filter-name>testFilter</filter-name>

  8.        <filter-class>com.TestFilter</filter-class>

  9.        <async-supported>true</async-supported>

  10.    </filter>

  11.    <servlet>

  12.        <servlet-name>mvc-dispatcher</servlet-name>

  13.        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

  14.        .........

  15.        <async-supported>true</async-supported>

  16.    </servlet>

  • 使用springmvc封裝了servlet的AsyncContext，使用起來比較簡單。以前我們同步的模式的Controller是返回額ModelAndView，而非同步模式直接生成一個defrredResult(支援我們超時擴充套件)即可儲存上下文,下面給出如何和我們HttpClient搭配的簡單demo

  1. @RequestMapping(value="/asynctask", method = RequestMethod.GET)

  2.    public DeferredResult<String> asyncTask() throws IOReactorException {

  3.        IOReactorConfig ioReactorConfig = IOReactorConfig.custom().setIoThreadCount(1).build();

  4.        ConnectingIOReactor ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);

  5.        PoolingNHttpClientConnectionManager conManager = new PoolingNHttpClientConnectionManager(ioReactor);

  6.        conManager.setMaxTotal(100);

  7.        conManager.setDefaultMaxPerRoute(100);

  8.        CloseableHttpAsyncClient httpclient = HttpAsyncClients.custom().setConnectionManager(conManager).build();

  9.        // Start the client

  10.        httpclient.start();

  11.        //設定超時時間200ms

  12.        final DeferredResult<String> deferredResult = new DeferredResult<String>(200L);

  13.        deferredResult.onTimeout(new Runnable() {

  14.            @Override

  15.            public void run() {

  16.                System.out.println("非同步呼叫執行超時！thread id is : " + Thread.currentThread().getId());

  17.                deferredResult.setResult("超時了");

  18.            }

  19.        });

  20.        System.out.println("/asynctask 呼叫！thread id is : " + Thread.currentThread().getId());

  21.        final HttpGet request2 = new HttpGet("http://www.apache.org/");

  22.        httpclient.execute(request2, new FutureCallback<HttpResponse>() {

  23.            public void completed(final HttpResponse response2) {

  24.                System.out.println(request2.getRequestLine() + "->" + response2.getStatusLine());

  25.                deferredResult.setResult(request2.getRequestLine() + "->" + response2.getStatusLine());

  26.            }

  27.            public void failed(final Exception ex) {

  28.                System.out.println(request2.getRequestLine() + "->" + ex);

  29.            }

  30.            public void cancelled() {

  31.                System.out.println(request2.getRequestLine() + " cancelled");

  32.            }

  33.        });

  34.        return deferredResult;

  35.    }

注意: 在serlvet非同步化中有個問題是filter的後置結果處理，沒法使用，對於我們一些打點，結果統計直接使用serlvet非同步是沒法用的。在springmvc中就很好的解決了這個問題，springmvc採用了一個比較取巧的方式通過請求轉發，能讓請求再次過濾器。但是又引入了新的一個問題那就是過濾器會處理兩次，這裡可以通過SpringMVC原始碼中自身判斷的方法，我們可以在filter中使用下面這句話來進行判斷是不是屬於springmvc轉發過來的請求，從而不處理filter的前置事件，只處理後置事件:

  1. Object asyncManagerAttr = servletRequest.getAttribute(WEB_ASYNC_MANAGER_ATTRIBUTE);

  2. return asyncManagerAttr instanceof WebAsyncManager ;

5.全鏈路非同步化

上面我們介紹了serlvet的非同步化，相信細心的同學都看出來似乎並沒有解決根本的問題，我的IO阻塞依然存在，只是換了個位置而已，當IO呼叫頻繁同樣會讓業務執行緒池快速變滿，雖然serlvet容器執行緒不被阻塞，但是這個業務依然會變得不可用。

那麼怎麼才能解決上面的問題呢？答案就是全鏈路非同步化，全鏈路非同步追求的是沒有阻塞，打滿你的CPU,把機器的效能壓榨到極致模型圖如下:

具體的NIO client到底做了什麼事呢，具體如下面模型：

上面就是我們全鏈路非同步的圖了(部分執行緒池可以優化)。全鏈路的核心在於只要我們遇到IO呼叫的時候，我們就可以使用NIO，從而避免阻塞，也就解決了之前說的業務執行緒池被打滿得到尷尬場景。

5.1遠端呼叫非同步化

我們一般遠端呼叫使用rpc或者http。對於rpc來說一般thrift,http,motan等支援都非同步呼叫，其內部原理也都是採用事件驅動的NIO模型，對於http來說一般的apachehttpclient和okhttp也都提供了非同步呼叫。 下面簡單介紹下Http非同步化呼叫是怎麼做的: 首先來看一個例子:

  1. public class HTTPAsyncClientDemo {

  2.    public static void main(String[] args) throws ExecutionException, InterruptedException, IOReactorException {

  3.      //具體引數含義下文會講

  4.       //apache提供了ioReactor的引數配置，這裡我們配置IO 執行緒為1

  5.        IOReactorConfig ioReactorConfig = IOReactorConfig.custom().setIoThreadCount(1).build();

  6.      //根據這個配置建立一個ioReactor

  7.        ConnectingIOReactor ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);

  8.      //asyncHttpClient使用PoolingNHttpClientConnectionManager管理我們客戶端連線

  9.        PoolingNHttpClientConnectionManager conManager = new PoolingNHttpClientConnectionManager(ioReactor);

  10.      //設定總共的連線的最大數量

  11.        conManager.setMaxTotal(100);

  12.      //設定每個路由的連線的最大數量

  13.        conManager.setDefaultMaxPerRoute(100);

  14.      //建立一個Client

  15.        CloseableHttpAsyncClient httpclient = HttpAsyncClients.custom().setConnectionManager(conManager).build();

  16.        // Start the client

  17.        httpclient.start();

  18.        // Execute request

  19.        final HttpGet request1 = new HttpGet("http://www.apache.org/");

  20.        Future<HttpResponse> future = httpclient.execute(request1, null);

  21.        // and wait until a response is received

  22.        HttpResponse response1 = future.get();

  23.        System.out.println(request1.getRequestLine() + "->" + response1.getStatusLine());

  24.        // One most likely would want to use a callback for operation result

  25.        final HttpGet request2 = new HttpGet("http://www.apache.org/");

  26.        httpclient.execute(request2, new FutureCallback<HttpResponse>() {

  27.                        //Complete成功後會回撥這個方法

  28.            public void completed(final HttpResponse response2) {

  29.                System.out.println(request2.getRequestLine() + "->" + response2.getStatusLine());

  30.            }

  31.            public void failed(final Exception ex) {

  32.                System.out.println(request2.getRequestLine() + "->" + ex);

  33.            }

  34.            public void cancelled() {

  35.                System.out.println(request2.getRequestLine() + " cancelled");

  36.            }

  37.        });

  38.    }

  39. }

下面給出httpAsync的整個類圖:

對於我們的HTTPAysncClient 其實最後使用的是InternalHttpAsyncClient,在InternalHttpAsyncClient中有個ConnectionManager，這個就是我們管理連線的管理器，而在httpAsync中只有一個實現那就是PoolingNHttpClientConnectionManager,這個連線管理器中有兩個我們比較關心的一個是Reactor,一個是Cpool。

  • Reactor :所有的Reactor這裡都是實現了IOReactor介面。在PoolingNHttpClientConnectionManager中會有擁有一個Reactor，那就是DefaultConnectingIOReactor,這個DefaultConnectingIOReactor,負責處理Acceptor。在DefaultConnectingIOReactor有個excutor方法，生成IOReactor也就是我們圖中的BaseIOReactor，進行IO的操作。這個模型就是我們上面的1.2.2的模型

  • CPool :在PoolingNHttpClientConnectionManager中有個CPool，主要是負責控制我們連線，我們上面所說的maxTotal和defaultMaxPerRoute，都是由其進行控制，如果每個路由的滿了他會斷開最老的一個連結，如果總共的total滿了他會放入leased佇列，釋放空間的時候就會將其重新連線。

5.2資料庫呼叫非同步化

對於資料庫呼叫一般的框架並沒有提供非同步化的方法，這裡推薦自己封裝或者使用網上開源的，這裡我們公司有個開源的 https://github.com/ainilife/zebra-dao/blob/master/README_ZH.md 能很好的支援非同步化

6.最後

非同步化並不是高併發的銀彈，但是有了非同步化的確能提高你機器的qps，吞吐量等等。上述講的一些模型如果能合理的做一些優化，然後進行應用，相信能對你的服務有很大的幫助的。

相關推薦

非同步化，高併發大殺器

聊聊如何讓專案非同步化的一些事。 1.同步和非同步，阻塞和非阻塞 同步和非同步，阻塞和非阻塞, 這個幾個詞已經是老生常談，當時常常還是有很多同學分不清楚，以為同步肯定就是阻塞，非同步肯定就是非阻塞，其他他們不是一回事。 同步和非同步關注的是結果訊息的通訊機制 同步

並行化-你的高併發大殺器

1.前言 想必熱愛遊戲的同學小時候，都幻想過要是自己要是能像鳴人那樣會多重影分身之術，就能一邊打遊戲一邊上課了，可惜漫畫就是漫畫，現實中並沒有這個技術，你要麼只有老老實實的上課，要麼就只有逃課去打遊戲了。雖然在現實中我們無法實現多重影分身這樣的技術，但是我們可以在計算機世界

異步化，高並發大殺器

ktr apach tco 序列 etc 當前 本質 就會 out 聊聊如何讓項目異步化的一些事。 1.同步和異步，阻塞和非阻塞 同步和異步，阻塞和非阻塞, 這個幾個詞已經是老生常談，當時常常還是有很多同學分不清楚，以為同步肯定就是阻塞，異步肯定就是非阻塞，其他他們不是一回

mysql主從複製，資料量大， 高併發時，出現數據不一致

mysql5.7的並行複製就可以解決資料延遲的問題。 MySQL 5.7並行複製時代 眾所周知，MySQL的複製延遲是一直被詬病的問題之一，然而在Inside君之前的兩篇部落格中（1，2）中都已經提到了MySQL 5.7版本已經支援“真正”的並行複製功能，官方稱為

1.9 開始第一幅“碼繪”——掌握大殺器”迴圈“，一招搞定百千萬個懵逼臉

引言：重複與美 這一節裡，我們將要學到一項強大的技能——迴圈。 有了迴圈，我們就能夠指揮計算機幫我們去做大量重複性的事情。 直覺上，提到“重複”，往往聯想到枯燥乏味。的確，從操作而言，重複

spacemacs:emacs和vim結合，大殺器。vim黨轉emacs

結合本人基礎，做下述結論。不一定準確。 基礎： 1. vim操作和高階操作，熟悉。使用的spf13-vim。 2. emacs以前學過，但是按鍵太累，相比vim簡直難受。 3. emacs命令太

Java架構師，大資料架構師，高併發設計模式，機器學習知識點分享

第一章：java精品課程目錄大全 1、億級流量電商詳情頁系統的大型高併發與高可用快取架構實戰 1課程介紹以及高併發高可用複雜系統中的快取架構有哪些東西？32分鐘 2基於大型電商網站中的商品詳情頁系

大資料量，高併發解決方案

解決大資料量高併發要考慮多方面的1.HTML靜態化2.靜態檔案伺服器分離  如圖片、css、js檔案等；3.資料庫叢集4.負載均衡5.快取6.讀寫分離Discuz!NT資料庫讀寫分離方案，我感覺這個還不錯http://www.cnblogs.com/daizhj/archiv

單頁面(如react，vue)網站的伺服器渲染 SSR 之 SEO 大殺器 Rendertron

單頁面網站，比如vue、recat框架的網站，一般都是直接從伺服器推送index.html，再根據自身路由通過js在客戶端瀏覽器渲染出完整的html頁面。 但是搜尋引擎的爬蟲可沒有這麼智慧（實際上google就有這麼智慧，拿到js檔案自動幫你渲染好，但身在CN，將就下百度這個阿斗吧），為了SEO，要想爬蟲爬到

【高併發】高併發秒殺系統架構解密，不是所有的秒殺都是秒殺！

前言 很多小夥伴反饋說，高併發專題學了那麼久，但是，在真正做專案時，仍然不知道如何下手處理高併發業務場景！甚至很多小夥伴仍然停留在只是簡單的提供介面（CRUD）階段，不知道學習的併發知識如何運用到實際專案中，就更別提如何構建高併發系統了！ 究竟什麼樣的系統算是高併發系統？今天，我們就一起解密高併發業務場景

【高併發】Redis如何助力高併發秒殺系統，看完這篇我徹底懂了！！

## 寫在前面 > 之前，我們在《[【高併發】高併發秒殺系統架構解密，不是所有的秒殺都是秒殺！](https://mp.weixin.qq.com/s?__biz=Mzg3MzE1NTIzNA==&mid=2247484357&idx=1&sn=23e6e38143704db0

產品經理的流程總是變，所以我搬出了大殺器狀態機模式

大家好，今天給大家介紹一個新的設計模式，這個設計模式非常重要，在我們日常的開發工作當中經常使用。它就是大名鼎鼎的狀態機模式。 狀態機模式非常適合用在複雜的流程或者是系統當中，可以方便我們對系統的某一個狀態進行抽象，這會讓我們編碼具有更強的可讀性以及延展性。 有向圖與DAG 首先和大家解釋一下狀態機當中這個狀態

一文讀懂機器學習大殺器XGBoost原理

結構 近似算法 機器 form con gin fff .cn tran http://blog.itpub.net/31542119/viewspace-2199549/ XGBoost是boosting算法的其中一種。Boosting算法的思想是將許多弱分類器集成在

tornado非同步原理(2)——高併發

如下程式碼所示，當tornado web server 的TCPSever接收到客戶端的socket時，會將該soket新增至ioloop監聽列表， 當socket可讀時，ioloop會呼叫回掉函式tcpserver._handle_connection()函式 —— tornado io非同步事件

JAVA微服務架構，高併發，高效能，高可用，分散式，叢集，快取，電商實戰教程下載

JAVA微服務架構，高併發，高效能，高可用，分散式，叢集，快取，電商實戰教程下載39套Java架構師，高併發，高效能，高可用，分散式，叢集，電商，快取，微服務，微信支付寶支付，公眾號開發，java8新特性，P2P金融專案，程式設計，功能設計，資料庫設計，第三方支付，web安全，效能調優，設計模式，資

redis高併發秒殺測試

專案原始碼：https://pan.baidu.com/s/1KfTRyghgUqvkpBCHN6xJwg 準備 使用docker-compose命令啟動redis伺服器（可以用其他方式啟動） idea啟動測試專案 jmeter測試指令碼 高併發秒殺-重現

SpringBoot實現Java高併發秒殺系統之併發優化

秒殺系統架構的設計和優化分析，以我一個小菜雞，目前是說不出來的o(╥﹏╥)o。 因此呢，我這裡僅從本專案已經實現的優化來介紹一下： 本專案中做到了以下優化： 秒殺介面採用md5加密方式防刷。 訂單表使用聯合主鍵方式，限制一個使用者只能購買該商品一次。 配合Spring事務

阿里、百度、京東一線網際網路架構師都在用的技術體系，高併發，微服務，軟體系統架構

可以說，Java是現階段中國網際網路公司中，覆蓋度最廣的研發語言，掌握了Java技術體系，不管在成熟的大公司，快速發展的公司，還是創業階段的公司，都能有立足之地。 有不少朋友問，除了掌握Java語法，還要系統學習哪些Java相關的技術，今天分享一個，網際網路Java技術學習路線圖。 一：常見模式

多執行緒，高併發的情況下操作redis當中的資料，如何加鎖？

多個執行緒同時去操作Redis當中的資料，假如不加鎖的情況下，會出現資料重複的問題。假如需要每次都只有一條執行緒去操作Redis當中的資料，需要給操作加上鎖。     但是去網上一搜，網上給Redis加鎖的機制都是利用Redis的setnx自身的方法去加鎖，但是這樣

Java架構師，大型電商，分散式，叢集，微服務，高併發，專案實戰

Java架構師，高併發，高效能，高可用，分散式，叢集，電商，快取，微服務，微信支付寶支付，公眾號開發，java8新特性，P2P金融專案，程式設計，功能設計，資料庫設計，第三方支付，web安全，效能調優，設計模式，資料結構，併發程式設計，虛擬機器，中介軟體，資料庫，專案實戰，大型分散式電商專案實戰視訊教程