HTTP連線的建立需要時間。如果我們要從一臺伺服器上獲取4個檔案，獲取每個檔案都要重新建立連線來獲取資料，這勢必會降低檔案下載效率，因為有一部分時間花費在建立連線上了，而不是真正在傳輸有用資料，如圖a所示：

如果我們能建立一個連線，傳輸完所有四個檔案，再關閉連線，必然會增加檔案下載效率，因為節省了多次建立連線的開銷，持久連線就是這樣的連線，它的工作方式如圖b所示：

簡單的持久連線有個問題，就是每次都要等到我們獲得了上一次請求的響應之後，才能發起下一次連線，這導致請求的時候，輸入流是完全閒置的，獲取響應的時候，輸出流是完全閒置的。如果我們能一邊傳送請求，一邊接收響應，這必然能更加充分的利用這個連線，可以被這樣使用的持久連線叫做管道化連線，它的工作方式如圖c所示：

下面給出的Java程式碼是通過一個管道化連線從伺服器上獲取多個檔案的示例：

package socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.file.Files;
import
 
 java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class ReuseSocket {
    public static void main(String[] args) throws UnknownHostException,
            IOException {
        String host = "www.cnblogs.com";
        int port = 80;
        String path = "/chenying99/p/3735282.html"
 
;
        String path2 = "/everSeeker/p/5462853.html";
        String result = getByPipePipelinedConnection(host, port, path, path2);
        writeFile(result, "d:/test/pipelined.html", "utf-8");
    }

    /**
     * 通過一個管道化連接獲取host指定的主機上paths指定的所有檔案
     * @param host 主機名
     * @param port 埠
     * @param paths host指定的主機上的檔案路徑集合
     * @return 伺服器返回的結果
     * @throws UnknownHostException
     * @throws IOException
     */
    public static String getByPipePipelinedConnection(String host, int port, 
            String...paths) throws UnknownHostException, IOException {
        StringBuilder lines = new StringBuilder();
        try(Socket socket = new Socket(host, port);
            // 輸出流
            PrintWriter printWriter = new PrintWriter((new OutputStreamWriter(
                    socket.getOutputStream(), "utf-8")));
            // 輸入流
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(
                            socket.getInputStream(), "utf-8"));
            ) {
            for (String path : paths) {
                String requestHead = generateRequestHead(host, path);
                printWriter.println(requestHead);
                printWriter.flush();
            }

            String line = null;
            while ((line = bufferedReader.readLine()) != null) {
                lines.append(line);
                lines.append(System.lineSeparator());
            }
        }
        return lines.toString();
    }

    /**
     * 
     * @param host 主機名
     * @param path 主機上某個檔案的路徑
     * @return 獲得host指定主機上的path指定的檔案的請求頭
     */
    private static String generateRequestHead(String host, String path) {
        StringBuffer requestHeader = new StringBuffer();
        requestHeader
                .append("GET " + path + " HTTP/1.1\n")
                .append("Accept: text/html, application/xhtml+xml, */*\n")
                .append("Accept-Language:zh-CN,zh;q=0.8\n")
                .append("User-Agent: Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)\n")
                .append("HOST:" + host + "\n")
                .append("\n");
        return requestHeader.toString();
    }

    /**
     * 把字串寫進檔案，檔案已經存在會覆蓋原檔案
     * @param content 字串
     * @param pathName 檔案路徑名
     * @param charsetName 字符集
     */
    private static void writeFile(String content, String pathName, String charsetName) {
        Path path = Paths.get(pathName);
        try {
            Files.write(path, content.getBytes(charsetName), StandardOpenOption.CREATE);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

想更細緻的瞭解管道化連線，可以閱讀《HTTP權威指南》4.6節，本文的圖也來自這本書。