java中如何模拟真正的同時并發請求？

　　有時需要測試一下某個功能的并發性能，又不要想借助于其他工具，索性就自己的開發語言，來一個并發請求就最友善了。

　　java中模拟并發請求，自然是很友善的，隻要多開幾個線程，發起請求就好了。但是，這種請求，一般會存在啟動的先後順序了，算不得真正的同時并發！怎麼樣才能做到真正的同時并發呢？是本文想說的點，java中提供了閉鎖 CountDownLatch, 剛好就用來做這種事就最合适了。

　　隻需要：

1. 開啟n個線程，加一個閉鎖，開啟所有線程；

2. 待所有線程都準備好後，按下開啟按鈕，就可以真正的發起并發請求了。

package com.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.CountDownLatch;

public class LatchTest {

    public static void main(String[] args) throws InterruptedException {
        Runnable taskTemp = new Runnable() {

　　　　　　　// 注意，此處是非線程安全的，留坑
            private int iCounter;

            @Override
            public void run() {
                for(int i = 0; i < 10; i++) {
                    // 發起請求
//                    HttpClientOp.doGet("https://www.baidu.com/");
                    iCounter++;
                    System.out.println(System.nanoTime() + " [" + Thread.currentThread().getName() + "] iCounter = " + iCounter);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        LatchTest latchTest = new LatchTest();
        latchTest.startTaskAllInOnce(5, taskTemp);
    }

    public long startTaskAllInOnce(int threadNums, final Runnable task) throws InterruptedException {
        final CountDownLatch startGate = new CountDownLatch(1);
        final CountDownLatch endGate = new CountDownLatch(threadNums);
        for(int i = 0; i < threadNums; i++) {
            Thread t = new Thread() {
                public void run() {
                    try {
                        // 使線程在此等待，當開始門打開時，一起湧入門中
                        startGate.await();
                        try {
                            task.run();
                        } finally {
                            // 将結束門減1，減到0時，就可以開啟結束門了
                            endGate.countDown();
                        }
                    } catch (InterruptedException ie) {
                        ie.printStackTrace();
                    }
                }
            };
            t.start();
        }
        long startTime = System.nanoTime();
        System.out.println(startTime + " [" + Thread.currentThread() + "] All thread is ready, concurrent going...");
        // 因開啟門隻需一個開關，是以立馬就開啟開始門
        startGate.countDown();
        // 等等結束門開啟
        endGate.await();
        long endTime = System.nanoTime();
        System.out.println(endTime + " [" + Thread.currentThread() + "] All thread is completed.");
        return endTime - startTime;
    }
}

其執行效果如下圖所示：

httpClientOp 工具類，可以使用成熟的工具包，也可以自己寫一個簡要的通路方法，參考如下：

class HttpClientOp {
    public static String doGet(String httpurl) {
        HttpURLConnection connection = null;
        InputStream is = null;
        BufferedReader br = null;
        String result = null;// 傳回結果字元串
        try {
            // 建立遠端url連接配接對象
            URL url = new URL(httpurl);
            // 通過遠端url連接配接對象打開一個連接配接，強轉成httpURLConnection類
            connection = (HttpURLConnection) url.openConnection();
            // 設定連接配接方式：get
            connection.setRequestMethod("GET");
            // 設定連接配接主機伺服器的逾時時間：15000毫秒
            connection.setConnectTimeout(15000);
            // 設定讀取遠端傳回的資料時間：60000毫秒
            connection.setReadTimeout(60000);
            // 發送請求
            connection.connect();
            // 通過connection連接配接，擷取輸入流
            if (connection.getResponseCode() == 200) {
                is = connection.getInputStream();
                // 封裝輸入流is，并指定字元集
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                // 存放資料
                StringBuffer sbf = new StringBuffer();
                String temp = null;
                while ((temp = br.readLine()) != null) {
                    sbf.append(temp);
                    sbf.append("\r\n");
                }
                result = sbf.toString();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 關閉資源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            connection.disconnect();// 關閉遠端連接配接
        }

        return result;
    }

    public static String doPost(String httpUrl, String param) {

        HttpURLConnection connection = null;
        InputStream is = null;
        OutputStream os = null;
        BufferedReader br = null;
        String result = null;
        try {
            URL url = new URL(httpUrl);
            // 通過遠端url連接配接對象打開連接配接
            connection = (HttpURLConnection) url.openConnection();
            // 設定連接配接請求方式
            connection.setRequestMethod("POST");
            // 設定連接配接主機伺服器逾時時間：15000毫秒
            connection.setConnectTimeout(15000);
            // 設定讀取主機伺服器傳回資料逾時時間：60000毫秒
            connection.setReadTimeout(60000);

            // 預設值為：false，當向遠端伺服器傳送資料/寫資料時，需要設定為true
            connection.setDoOutput(true);
            // 預設值為：true，目前向遠端服務讀取資料時，設定為true，該參數可有可無
            connection.setDoInput(true);
            // 設定傳入參數的格式:請求參數應該是 name1=value1&name2=value2 的形式。
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            // 設定鑒權資訊：Authorization: Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0
            connection.setRequestProperty("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
            // 通過連接配接對象擷取一個輸出流
            os = connection.getOutputStream();
            // 通過輸出流對象将參數寫出去/傳輸出去,它是通過位元組數組寫出的
            os.write(param.getBytes());
            // 通過連接配接對象擷取一個輸入流，向遠端讀取
            if (connection.getResponseCode() == 200) {

                is = connection.getInputStream();
                // 對輸入流對象進行包裝:charset根據工作項目組的要求來設定
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));

                StringBuffer sbf = new StringBuffer();
                String temp = null;
                // 循環周遊一行一行讀取資料
                while ((temp = br.readLine()) != null) {
                    sbf.append(temp);
                    sbf.append("\r\n");
                }
                result = sbf.toString();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 關閉資源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 斷開與遠端位址url的連接配接
            connection.disconnect();
        }
        return result;
    }
}

　　如上，就可以發起真正的并發請求了。

并發請求操作流程示意圖如下：

　　此處設定了一道門，以保證所有線程可以同時生效。但是，此處的同時啟動，也隻是語言層面的東西，也并非絕對的同時并發。具體的調用還要依賴于CPU個數，線程數及作業系統的線程排程功能等，不過咱們也無需糾結于這些了，重點在于了解原理！

　　與 CountDownLatch 有類似功能的，還有個工具栅欄 CyclicBarrier, 也是提供一個等待所有線程到達某一點後，再一起開始某個動作，效果一緻，不過栅欄的目的确實比較純粹，就是等待所有線程到達，而前面說的閉鎖 CountDownLatch 雖然實作的也是所有線程到達後再開始，但是他的觸發點其實是最後那一個開關，是以側重點是不一樣的。

　　簡單看一下栅欄是如何實作真正同時并發呢？示例如下：

// 與 閉鎖 結構一緻
public class LatchTest {

    public static void main(String[] args) throws InterruptedException {
    
        Runnable taskTemp = new Runnable() {

            private int iCounter;

            @Override
            public void run() {
                // 發起請求
//              HttpClientOp.doGet("https://www.baidu.com/");
                iCounter++;
                System.out.println(System.nanoTime() + " [" + Thread.currentThread().getName() + "] iCounter = " + iCounter);
            }
        };

        LatchTest latchTest = new LatchTest();
//        latchTest.startTaskAllInOnce(5, taskTemp);
        latchTest.startNThreadsByBarrier(5, taskTemp);
    }

    public void startNThreadsByBarrier(int threadNums, Runnable finishTask) throws InterruptedException {
        // 設定栅欄解除時的動作，比如初始化某些值
        CyclicBarrier barrier = new CyclicBarrier(threadNums, finishTask);
        // 啟動 n 個線程，與栅欄閥值一緻，即當線程準備數達到要求時，栅欄剛好開啟，進而達到統一控制效果
        for (int i = 0; i < threadNums; i++) {
            Thread.sleep(100);
            new Thread(new CounterTask(barrier)).start();
        }
        System.out.println(Thread.currentThread().getName() + " out over...");
    }
}


class CounterTask implements Runnable {

    // 傳入栅欄，一般考慮更優雅方式
    private CyclicBarrier barrier;

    public CounterTask(final CyclicBarrier barrier) {
        this.barrier = barrier;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName() + " - " + System.currentTimeMillis() + " is ready...");
        try {
            // 設定栅欄，使在此等待，到達位置的線程達到要求即可開啟大門
            barrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " - " + System.currentTimeMillis() + " started...");
    }
}

其運作結果如下圖：

　　各有其應用場景吧，關鍵在于需求。就本文示例的需求來說，個人更願意用閉鎖一點，因為更可控了。但是代碼卻是多了，是以看你喜歡吧！

不要害怕今日的苦，你要相信明天，更苦！

java中如何模拟真正的同時并發請求？

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method