最近是做了半年的專案到了最後測試準備上線了，流程走通後開始做一些效能測試，在此期間做了很多效能優化的工作，在此做下筆記，分享一下。交流一下，希望同道中人有新的東西歡迎補充。在此就不做太多的具體操作，主要還是從思路上出發。

      效能優化主要從幾個方面著手。

      1.從架構設計的角度

           現在的web專案不再像七八年前以前的專案單個的動態web工程就能滿足效能的要求了，現如今專案只要是抱著一個美好前景的話，一般都會假設自己的專案未來是PB級資料量，億級使用者量，幾萬併發的賺暴的獨角獸專案，無論是電商，新浪，搜狐等入口網站都會有大量資料，大量的使用者，現在熱門的物聯網雖然使用者量沒有大規模，然而一堆一堆的感測器從不覺得累地同時訪問你，產生大量的資料。

          為此，要想你的系統在滿足要求的情況下扛住壓力實現高可用，靠提高硬體已經價效比上不能接收。如下是一張簡單流行的分散式架構圖，不全面，只用來說明一下效能方面相關：

      

     上圖web伺服器一般以叢集的形式，用lvs,Nginx等開源工具做反向代理和API層的負載均衡。業務層service可以用Dubbo等RPC框架實現分散式呼叫，達到多節點同時處理計算，現在又有一種新的趨勢，以springboot框架做微服務進行服務間以restful介面呼叫，兩種形式各有千秋，前者較後都就目前來說更流行一些，在此只關注對效能相關的話題。

    另外，使用redis，memcache等開源工具做快取對效能也有較大的提高，當然也會有一些管理難的代價，管理不好經常出現數據不一致。

2.從資料庫的角度

關係形資料庫在資料量達到一定規模查詢效果較差，像一些操作紀錄等資料可以用elasticsearch,redis,mongodb等nosql非關係形資料庫來儲存，查詢效能比關係形資料庫好很多，但是比如金錢，訂單，使用者資訊等“貴重”資訊只能用關係形資料庫來儲存。關係形資料庫效能提高常的方法一般包括建立索引，檢視等。有些資料庫如mysql官方還提供代理工具實現水平拆分，垂直拆分等，Mysql proxy代理工具可以實現資料庫的讀寫分離，都能一定程式提高關係資料庫的效能。

3.從程式碼的角度

        進入一家新公司後，一般架構都已經定了，為了效能動架構的機會不是很多，除非決定整個專案重構，難道在效能方面就沒有辦法了嗎？答案是否定的，java真的是一門神奇的語言，可能簡潔度上不如php語言，效能不如c++,api沒有scala豐富，也沒有golang那麼高效，然而java是最中庸的，綜合實力最強。在此為java點個贊，好了，還是上程式碼吧。

          比如有個需求，第一步要呼叫北京總公司的中控伺服器拿token等驗證資訊，平均耗時要1秒，調本系統查詢訂單處理要2秒，調百度上傳圖片要2秒，調阿里支付要3秒，有一個方法裡面全部完成這些操作，普通的寫法如下：

package com.web.service.back.impl;

import java.util.concurrent.TimeUnit;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy;

@Controller
public class PayOrder {

    @RequestMapping("pay")
    @ResponseBody
    public Boolean payGood(String userName, String password, double money) throws InterruptedException {
        String token = getToken(userName, password);// 1秒
        String url = upLoadPic();// 2秒
        double totalFee = dealOrder(userName);// 返回總金額 2秒
        payMoney(totalFee);//3秒

        return true;

    }

    private String upLoadPic() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        return "url";
    }

    private void payMoney(double totalFee) throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
    }

    private double dealOrder(String userName) throws InterruptedException {
        double sum = 0;
        for (int i = 0; i < 20; i++) {
            TimeUnit.MILLISECONDS.sleep(100);// 模擬處理單個訂單消耗00毫秒，20個訂單為2秒
            sum += i * 50.00;
        }

        return sum;
    }

    private String getToken(String userName, String password) throws InterruptedException {
        TimeUnit.SECONDS.sleep(1);// 模擬呼叫時間為2秒
        return "123456";
    }
}

   這樣的結果有點嚇人，總的消耗時間為 1+2+2+3 =8秒，這在生產環境是不能被忍受的。上面程式碼是序列執行，我們可以做以下處理   第一步：非同步處理，上程式碼    

 @RequestMapping("pay")
    @ResponseBody
    public Boolean payGood(String userName, String password, double money) throws InterruptedException {

        ExecutorService pool = Executors.newCachedThreadPool();
        Future<Double> totalFeeFuture = pool.submit(new Callable<Double>() {

            @Override
            public Double call() throws Exception {
                return dealOrder(userName);// 返回總金額 2秒
            }
        });

        Future<String> tokenFuture = pool.submit(new Callable<String>() {

            @Override
            public String call() throws Exception {
                return getToken(userName, password);// 2秒
            }
        });

        Future<String> picUrlFuture = pool.submit(new Callable<String>() {

            @Override
            public String call() throws Exception {
                return upLoadPic();// 2秒
            }
        });

        pool.submit(new Runnable() {

            @Override
            public void run() {
                try {
                    payMoney(totalFeeFuture.get(2, TimeUnit.SECONDS));// 設定超時設定
                } catch (InterruptedException | ExecutionException | TimeoutException e) {
                    e.printStackTrace();
                } // 3秒
            }
        });

        try {
            String url = picUrlFuture.get(2, TimeUnit.SECONDS);
            tokenFuture.get(2, TimeUnit.SECONDS);
        } catch (ExecutionException | TimeoutException e) {
            e.printStackTrace();
        }

        return true;

    }

   這樣的結果大約就是    2秒左右；future模式，可以先返回一個Future給呼叫者，主執行緒可以立即得到返回，往下執行，等需要得到結果時呼叫future.get()方法獲取結果，此方法會阻塞，當然可以設定一個超時時間， 防止程式死在這裡，提醒一下，向這種非同步處理應該在依賴的返回結果的情況下，有兩個原則:    a.有回撥的也就是傳Callable引數的應該越早越省時間。    b.消耗時間越長的呼叫越先執行。   如果你參與的專案有幸用的是java8，java8中有CompletableFuture增強Future，自帶forkJorkPool執行緒池。也可以自已指定執行緒池。上程式碼，上面主方法可改為：

  @RequestMapping("pay")
    @ResponseBody
    public Boolean payGood(String userName, String password, double money)  {
        
        try {
            CompletableFuture<Double> totalFeeFuture = CompletableFuture.supplyAsync(() -> dealOrder(userName));
            CompletableFuture<String> tokenFuture = CompletableFuture.supplyAsync(() -> getToken(userName, password));
            CompletableFuture<String> picUrlFuture = CompletableFuture.supplyAsync(() -> upLoadPic());
            CompletableFuture.runAsync(() -> payMoney(totalFeeFuture.get(2, TimeUnit.SECONDS)));
    
      String token = tokenFuture.get();
      String url =  picUrlFuture.get();
        } catch (InterruptedException | ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return true;

    }

 簡潔吧？ lambda表示式威力是不是很大？來來，我們繼續，

private double dealOrder(String userName) throws InterruptedException {
        double sum = 0;
        for (int i = 0; i < 20; i++) {
            TimeUnit.MILLISECONDS.sleep(100);// 模擬處理單個訂單消耗00毫秒，20個訂單為2秒
            sum += i * 50.00;
        }

        return sum;
    }

處理訂單是在一個序列20次迴圈中處理，感覺也糟糕透了。下面提供兩程優化。第一種countDownLatch

     double sum = 0;
    private double dealOrder(String userName) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(20);
        ExecutorService pool = Executors.newFixedThreadPool(10);
        pool.execute(new Runnable() {
            AtomicInteger i = new AtomicInteger(0);
            @Override
            public void run() {
                sum += i.doubleValue()*50.00;
                i.incrementAndGet();
                latch.countDown();
            }
        });
        latch.await();

        return sum;
    }

這裡await()方法會阻塞. 第二種,java8並行流：

private double dealOrder(String userName) throws InterruptedException {
       
        double sum = IntStream.rangeClosed(0, 20).parallel().asDoubleStream().map((i) -> i*50.00).reduce(0, Double::sum);

        return sum;
    }

好了就寫這麼多吧。下次再寫吧。孩子想爸爸了，回家 a