構建C1000K的服務器(1) – 基礎

時間  2019-12-08
標籤 構建 c1000k 服務器 基礎 欄目 C&C++ 简体版
原文   原文鏈接

轉自： http://www.ideawu.net/blog/archives/740.html

html

著名的 C10K 問題提出的時候, 正是 2001 年, 到現在 12 年後的 2013 年, C10K 已經不是問題了, 任何一個普通的程序員, 都能利用手邊的語言和庫, 輕鬆地寫出 C10K 的服務器. 這既得益於軟件的進步, 也得益於硬件性能的提升.linux

如今, 該是考慮 C1000K, 也就是百萬鏈接的問題的時候了. 像 Twitter, weibo, Facebook 這些網站, 它們的同時在線用戶有上千萬, 同時又但願消息能接近實時地推送給用戶, 這就須要服務器能維持和上千萬用戶的 TCP 網絡鏈接, 雖然可使用成百上千臺服務器來支撐這麼多用戶, 但若是每臺服務器能支持一百萬鏈接(C1000K), 那麼只須要十臺服務器.git

有不少技術聲稱能解決 C1000K 問題, 例如 Erlang, Java NIO 等等, 不過, 咱們應該首先弄明白, 什麼因素限制了 C1000K 問題的解決. 主要是這幾點:程序員

  1. 操做系統可否支持百萬鏈接?
  2. 操做系統維持百萬鏈接須要多少內存?
  3. 應用程序維持百萬鏈接須要多少內存?
  4. 百萬鏈接的吞吐量是否超過了網絡限制?

下面來分別對這幾個問題進行分析.github

1. 操做系統可否支持百萬鏈接?

對於絕大部分 Linux 操做系統, 默認狀況下確實不支持 C1000K! 由於操做系統包含最大打開文件數(Max Open Files)限制, 分爲系統全局的, 和進程級的限制.bash

全侷限制

在 Linux 下執行:服務器

cat /proc/sys/fs/file-nr

會打印出相似下面的一行輸出:網絡

5100	0	101747

　　

第三個數字 101747 就是當前系統的全局最大打開文件數(Max Open Files), 能夠看到, 只有 10 萬, 因此, 在這臺服務器上沒法支持 C1000K. 不少系統的這個數值更小, 爲了修改這個數值, 用 root 權限修改 /etc/sysctl.conf 文件:socket

fs.file-max = 1020000
net.ipv4.ip_conntrack_max = 1020000
net.ipv4.netfilter.ip_conntrack_max = 1020000

　　

須要重啓系統服務生效:tcp

# Linux
$ sudo sysctl -p /etc/sysctl.conf 
# BSD
$ sudo /etc/rc.d/sysctl reload

　　

進程限制

執行:

ulimit -n

　　

輸出:

1024

說明當前 Linux 系統的每個進程只能最多打開 1024 個文件. 爲了支持 C1000K, 你一樣須要修改這個限制.

臨時修改

ulimit -n 1020000

不過, 若是你不是 root, 可能不能修改超過 1024, 會報錯:

-bash: ulimit: open files: cannot modify limit: Operation not permitted

永久修改

編輯 /etc/security/limits.conf 文件, 加入以下行:

# /etc/security/limits.conf
work         hard    nofile      1020000
work         soft    nofile      1020000

第一列的 work 表示 work 用戶, 你能夠填 *, 或者 root. 而後保存退出, 從新登陸服務器.

注意: Linux 內核源碼中有一個常量(NR_OPEN in /usr/include/linux/fs.h), 限制了最大打開文件數, 如 RHEL 5 是 1048576(2^20), 因此, 要想支持 C1000K, 你可能還須要從新編譯內核.

2. 操做系統維持百萬鏈接須要多少內存?

解決了操做系統的參數限制, 接下來就要看看內存的佔用狀況. 首先, 是操做系統自己維護這些鏈接的內存佔用. 對於 Linux 操做系統, socket(fd) 是一個整數, 因此, 猜測操做系統管理一百萬個鏈接所佔用的內存應該是 4M/8M, 再包括一些管理信息, 應該會是 100M 左右. 不過, 還有 socket 發送和接收緩衝區所佔用的內存沒有分析. 爲此, 我寫了最原始的 C 網絡程序來驗證:

服務器

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <sys/select.h>

#define MAX_PORTS 10

int main(int argc, char **argv){
    struct sockaddr_in addr;
    const char *ip = "0.0.0.0";
    int opt = 1;
    int bufsize;
    socklen_t optlen;
    int connections = 0;
    int base_port = 7000;
    if(argc > 2){
        base_port = atoi(argv[1]);
    }

    int server_socks[MAX_PORTS];

    for(int i=0; i<MAX_PORTS; i++){
        int port = base_port + i;
        bzero(&addr, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons((short)port);
        inet_pton(AF_INET, ip, &addr.sin_addr);

        int serv_sock;
        if((serv_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1){
            goto sock_err;
        }
        if(setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1){
            goto sock_err;
        }
        if(bind(serv_sock, (struct sockaddr *)&addr, sizeof(addr)) == -1){
            goto sock_err;
        }
        if(listen(serv_sock, 1024) == -1){
            goto sock_err;
        }

        server_socks[i] = serv_sock;
        printf("server listen on port: %d\n", port);
    }

    //optlen = sizeof(bufsize);
    //getsockopt(serv_sock, SOL_SOCKET, SO_RCVBUF, &bufsize, &optlen);
    //printf("default send/recv buf size: %d\n", bufsize);

    while(1){
        fd_set readset;
        FD_ZERO(&readset);
        int maxfd = 0;
        for(int i=0; i<MAX_PORTS; i++){
            FD_SET(server_socks[i], &readset);
            if(server_socks[i] > maxfd){
                maxfd = server_socks[i];
            }
        }
        int ret = select(maxfd + 1, &readset, NULL, NULL, NULL);
        if(ret < 0){
            if(errno == EINTR){
                continue;
            }else{
                printf("select error! %s\n", strerror(errno));
                exit(0);
            }
        }

        if(ret > 0){
            for(int i=0; i<MAX_PORTS; i++){
                if(!FD_ISSET(server_socks[i], &readset)){
                    continue;
                }
                socklen_t addrlen = sizeof(addr);
                int sock = accept(server_socks[i], (struct sockaddr *)&addr, &addrlen);
                if(sock == -1){
                    goto sock_err;
                }
                connections ++;
                printf("connections: %d, fd: %d\n", connections, sock);
            }
        }
    }

    return 0;
sock_err:
    printf("error: %s\n", strerror(errno));
    return 0;
}

　　

注意, 服務器監聽了 10 個端口, 這是爲了測試方便. 由於只有一臺客戶端測試機, 最多隻能跟同一個 IP 端口建立 30000 多個鏈接, 因此服務器監聽了 10 個端口, 這樣一臺測試機就能夠和服務器之間建立 30 萬個鏈接了.

客戶端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>

int main(int argc, char **argv){
    if(argc <=  2){
        printf("Usage: %s ip port\n", argv[0]);
        exit(0);
    }

    struct sockaddr_in addr;
    const char *ip = argv[1];
    int base_port = atoi(argv[2]);
    int opt = 1;
    int bufsize;
    socklen_t optlen;
    int connections = 0;

    bzero(&addr, sizeof(addr));
    addr.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &addr.sin_addr);

    char tmp_data[10];
    int index = 0;
    while(1){
        if(++index >= 10){
            index = 0;
        }
        int port = base_port + index;
        printf("connect to %s:%d\n", ip, port);

        addr.sin_port = htons((short)port);

        int sock;
        if((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1){
            goto sock_err;
        }
        if(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1){
            goto sock_err;
        }

        connections ++;
        printf("connections: %d, fd: %d\n", connections, sock);

        if(connections % 10000 == 9999){
            printf("press Enter to continue: ");
            getchar();
        }
        usleep(1 * 1000);
        /*
           bufsize = 5000;
           setsockopt(serv_sock, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
           setsockopt(serv_sock, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
         */
    }

    return 0;
sock_err:
    printf("error: %s\n", strerror(errno));
    return 0;
}

　　

我測試 10 萬個鏈接, 這些鏈接是空閒的, 什麼數據也不發送也不接收. 這時, 進程只佔用了不到 1MB 的內存. 可是, 經過程序退出先後的 free 命令對比, 發現操做系統用了 200M(大體)內存來維護這 10 萬個鏈接! 若是是百萬鏈接的話, 操做系統自己就要佔用 2GB 的內存! 也即 2KB 每鏈接.

能夠修改

/proc/sys/net/ipv4/tcp_wmem
/proc/sys/net/ipv4/tcp_rmem

　　

來控制 TCP 鏈接的發送和接收緩衝的大小(多謝 @egmkang).

3. 應用程序維持百萬鏈接須要多少內存?

經過上面的測試代碼, 能夠發現, 應用程序維持百萬個空閒的鏈接, 只會佔用操做系統的內存, 經過 ps 命令查看可知, 應用程序自己幾乎不佔用內存.

4. 百萬鏈接的吞吐量是否超過了網絡限制?

假設百萬鏈接中有 20% 是活躍的, 每一個鏈接每秒傳輸 1KB 的數據, 那麼須要的網絡帶寬是 0.2M x 1KB/s x 8 = 1.6Gbps, 要求服務器至少是萬兆網卡(10Gbps).

總結

Linux 系統須要修改內核參數和系統配置, 才能支持 C1000K. C1000K 的應用要求服務器至少須要 2GB 內存, 若是應用自己還須要內存, 這個要求應該是至少 10GB 內存. 同時, 網卡應該至少是萬兆網卡.

固然, 這僅僅是理論分析, 實際的應用須要更多的內存和 CPU 資源來處理業務數據.

測試工具

測試操做系統最大鏈接數的工具: https://github.com/ideawu/c1000k

---------------------------

參考:

* http://www.cyberciti.biz/faq/linux-increase-the-maximum-number-of-open-files/
* http://www.lognormal.com/blog/2012/09/27/linux-tcpip-tuning/

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程