自己寫一個Web伺服器（3）

在Python中處理檔案和socket時，你通常會使用一個高層次的檔案/ Socket物件，但也有可能，你需要直接使用檔案描述符。這裡給出一個例子，你用write系統呼叫給標準輸出寫入一個字串，它將檔案描述符作為一個引數：

>>> import sys  
>>> import os  
>>> res = os.write(sys.stdout.fileno(), 'hello\n')  
hello

這是一個有趣的部分——你不會在感到驚訝，因為你已經知道在UNIX中所有的都是檔案——你的socket也有一個與其關聯的檔案描述符。繼續，我前面說到那樣建立一個socket你得到一個物件和一個非負整數，你總是可以直接通過fileno()方法獲取檔案描述符。

>>> import socket  
>>> sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
>>> sock.fileno()  
3

還有一件事情：你有沒有注意到注意到在第二個迭代伺服器webserver3b.py的例子中，伺服器在60秒休眠中你還可以通過第二個curl命令連線到伺服器。當然curl沒有立即有任何輸出，它掛起了，但是為什麼伺服器沒有在那時就接受連線，也沒有立即拒絕客戶端，而是允許它連線到伺服器呢？答案是socket物件的listen方法和它的BACKLOG 引數，在程式碼中是REQUEST_QUEUE_SIZE。BACKLOG 引數決定核心處理進來連線請求佇列的長度。伺服器 webserver3b.py休眠時，第二個curl能夠連線到伺服器是因為核心有足夠的空間給進來的連線請求。

增加BACKLOG 引數不能讓你的伺服器理解神奇到可以同時處理多個客戶端請求。要繁忙的伺服器不必等待繼而接受一個新的連線，而是立即從訊息佇列中抓取新的連線同時沒有延遲的開始一個客戶端響應程式，一個相當大的BACKLOG引數是非常重要的。

你已經瞭解夠多了。來快速回顧一下你目前為止所學的（或者複習一下你的基礎）。

• 迭代伺服器
• 伺服器socket建立過程（socket，bind，listen，accept）
• 客戶端socket建立過程（socket，connect）
• socket對
• socket
• 臨時埠和已知埠
• 程式
• 程式ID（PID），父程式ID（PPID），和父子關係
• 檔案描述符
• 監聽socket的BSCKLOG引數的意義

現在我準備回答第二篇的問題：你怎麼保證你的伺服器能同時處理多個請求？或者換個方式，如何編寫併發伺服器？

在UNIX下最簡單的方法是用一個fork()系統呼叫。

這是你新的兵法伺服器的程式碼[webserver3c.py](https://github.com/rspivak/lsbaws/blob/master/part3/webserver3c.py)，它可以同時處理多個客戶端請求（跟在迭代伺服器webserver3b.py一樣，每個子程式休眠60秒）：

###########################################################################  
# Concurrent server - webserver3c.py                                      #  
#                                                                         #  
# Tested with Python 2.7.9 & Python 3.4 on Ubuntu 14.04 & Mac OS X        #  
#                                                                         #  
# - Child process sleeps for 60 seconds after handling a client's request #  
# - Parent and child processes close duplicate descriptors                #  
#                                                                         #  
###########################################################################  
import os  
import socket  
import time

SERVER_ADDRESS = (HOST, PORT) = '', 8888  
REQUEST_QUEUE_SIZE = 5

def handle_request(client_connection):  
request = client_connection.recv(1024)  
print(  
'Child PID: {pid}. Parent PID {ppid}'.format(  
pid=os.getpid(),  
ppid=os.getppid(),  
)  
)  
print(request.decode())  
http_response = b"""\  
HTTP/1.1 200 OK

Hello, World!  
"""  
client_connection.sendall(http_response)  
time.sleep(60)

def serve_forever():  
listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  
listen_socket.bind(SERVER_ADDRESS)  
listen_socket.listen(REQUEST_QUEUE_SIZE)  
print('Serving HTTP on port {port} ...'.format(port=PORT))  
print('Parent PID (PPID): {pid}\n'.format(pid=os.getpid()))

while True:  
client_connection, client_address = listen_socket.accept()  
pid = os.fork()  
if pid == 0:  # child  
listen_socket.close()  # close child copy  
handle_request(client_connection)  
client_connection.close()  
os._exit(0)  # child exits here  
else:  # parent  
client_connection.close()  # close parent copy and loop over

if __name__ == '__main__':  
serve_forever()

在討論fork怎麼工作前，你自己看看這個伺服器卻是同時處理多個請求，而不像前連個。在命令列中用下面命令：

$ python webserver3c.py

接著執行連個curl命令，下載即便伺服器子程式處理客戶端請求後休眠60秒，卻並不影響其他客戶端，因為他們是完全不同的獨立程式了。你可以執行你儘可能多的curl命令（你想多少就多少），每一個都會沒有明顯延遲立即列印出伺服器響應“Hello, World” 。

理解fork()最重要的一點是你呼叫forl一次但是他返回兩次：一次是父程式，一次是子程式。你fork你個新的程式返回子程式的ID是0，返回父程式的是子程式的PID。

我還記得第一次看到並嘗試fork時是有多著迷。我正在看循序程式碼突然一聲響：程式碼複製了自己成為兩個同時執行的例項。我覺得這就是魔法，真的。

父程式fork出一個新子程式，這個子程式得到一個父程式檔案描述符：

你可能注意到上面程式碼的父程式關閉了客戶端連線：

else:  # parent
    client_connection.close()  # close parent copy and loop over

那麼子程式怎麼能繼續讀取客戶端socket資料，如果父程式已經關閉了和它的連線？答案就在上面的圖片中。核心根據檔案描述符的值來決定是否關閉連線socket，只有其值為0才會關閉。伺服器產生一個子程式，子程式拷貝父程式檔案描述符，核心增加引用描述符的值。在一個父程式一個子程式的例子中，描述符引用值就是2，當父程式關閉連線socket，它只會把引用值減為1，不會小島讓核心關閉socket。子程式也關閉了父程式監聽socket的重複拷貝，是因為它不關心接受新的客戶端連線，而只在乎處理已連線客戶端的響應：

listen_socket.close()  # close child copy

我會在這篇文章的後面談到你不取消重複描述符會發生什麼。

如你從當前伺服器程式碼中看到的，父程式的唯一職責是接受客戶端連線，fork一個子程式去處理客戶端請求，然後繼續接受另一個客戶端請求，沒別的。父程式不對客戶端請求做處理——子程式來做。

我們說兩個事件併發是什麼意思呢？

說兩事件併發通常是指他們在同一時間發生。作為一個簡短的定義是好的，但是你應該記住嚴格的定義：

如果你不能通過看這個程式來告訴你，這兩個事件是併發的。

又到了回顧概念和理念的時間了：

• 在UNIX下寫併發伺服器最簡單的方法是用fork()系統呼叫。
• 一個程式fork出一個新程式，它就變成新程式的父程式
• 呼叫fork後，父程式和子程式公用同樣的檔案描述符
• 核心用檔案描述符應用值來決定關閉或開啟檔案/socket
• 伺服器父程式的角色：從客戶端接受新的連線，fork一個子程式去處理請求，繼續接受新的連線。

我們來看看不取消父程式和子程式建重複描述符會發生什麼。對個當前伺服器程式碼稍作修改，webserver3d.py:

###########################################################################
# Concurrent server - webserver3d.py                                      #
#                                                                         #
# Tested with Python 2.7.9 & Python 3.4 on Ubuntu 14.04 & Mac OS X        #
###########################################################################
import os
import socket

SERVER_ADDRESS = (HOST, PORT) = '', 8888
REQUEST_QUEUE_SIZE = 5

def handle_request(client_connection):
    request = client_connection.recv(1024)
    http_response = b"""\
HTTP/1.1 200 OK

Hello, World!
"""
    client_connection.sendall(http_response)

def serve_forever():
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    listen_socket.bind(SERVER_ADDRESS)
    listen_socket.listen(REQUEST_QUEUE_SIZE)
    print('Serving HTTP on port {port} ...'.format(port=PORT))

    clients = []
    while True:
        client_connection, client_address = listen_socket.accept()
        # store the reference otherwise it's garbage collected
        # on the next loop run
        clients.append(client_connection)
        pid = os.fork()
        if pid == 0:  # child
            listen_socket.close()  # close child copy
            handle_request(client_connection)
            client_connection.close()
            os._exit(0)  # child exits here
        else:  # parent
            # client_connection.close()
            print(len(clients))

if __name__ == '__main__':
    serve_forever()

$ python webserver3d.py

$ curl http://localhost:8888/hello
Hello, World!

$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 3842
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 3842
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

$ ulimit -n 256

$ python webserver3d.py

#####################################################################
# Test client - client3.py                                          #
#                                                                   #
# Tested with Python 2.7.9 & Python 3.4 on Ubuntu 14.04 & Mac OS X  #
#####################################################################
import argparse
import errno
import os
import socket

SERVER_ADDRESS = 'localhost', 8888
REQUEST = b"""\
GET /hello HTTP/1.1
Host: localhost:8888

"""

def main(max_clients, max_conns):
    socks = []
    for client_num in range(max_clients):
        pid = os.fork()
        if pid == 0:
            for connection_num in range(max_conns):
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.connect(SERVER_ADDRESS)
                sock.sendall(REQUEST)
                socks.append(sock)
                print(connection_num)
                os._exit(0)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Test client for LSBAWS.',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    )
    parser.add_argument(
        '--max-conns',
        type=int,
        default=1024,
        help='Maximum number of connections per client.'
    )
    parser.add_argument(
        '--max-clients',
        type=int,
        default=1,
        help='Maximum number of clients.'
    )
    args = parser.parse_args()
    main(args.max_clients, args.max_conns)

$ python client3.py –max-clients=300

$ python webserver3d.py

$ curl http://localhost:8888/hello

$ ps auxw | grep -i python | grep -v grep
vagrant   9099  0.0  1.2  31804  6256 pts/0    S+   16:33   0:00 python webserver3d.py
vagrant   9102  0.0  0.0      0     0 pts/0    Z+   16:33   0:00 [python] <defunct>

$ ulimit -u 400
$ ulimit -n 500

$ python webserver3d.py

$ python client3.py --max-clients=500

###########################################################################
# Concurrent server - webserver3e.py                                      #
#                                                                         #
# Tested with Python 2.7.9 & Python 3.4 on Ubuntu 14.04 & Mac OS X        #
###########################################################################
import os
import signal
import socket
import time

SERVER_ADDRESS = (HOST, PORT) = '', 8888
REQUEST_QUEUE_SIZE = 5

def grim_reaper(signum, frame):
    pid, status = os.wait()
    print(
        'Child {pid} terminated with status {status}'
        '\n'.format(pid=pid, status=status)
    )

def handle_request(client_connection):
    request = client_connection.recv(1024)
    print(request.decode())
    http_response = b"""\
HTTP/1.1 200 OK

Hello, World!
"""
    client_connection.sendall(http_response)
    # sleep to allow the parent to loop over to 'accept' and block there
    time.sleep(3)

def serve_forever():
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    listen_socket.bind(SERVER_ADDRESS)
    listen_socket.listen(REQUEST_QUEUE_SIZE)
    print('Serving HTTP on port {port} ...'.format(port=PORT))

    signal.signal(signal.SIGCHLD, grim_reaper)

    while True:
        client_connection, client_address = listen_socket.accept()
        pid = os.fork()
        if pid == 0:  # child
            listen_socket.close()  # close child copy
            handle_request(client_connection)
            client_connection.close()
            os._exit(0)
        else:  # parent
            client_connection.close()

if __name__ == '__main__':
    serve_forever()

$ python webserver3e.py

$ curl http://localhost:8888/hello

###########################################################################
# Concurrent server - webserver3f.py                                      #
#                                                                         #
# Tested with Python 2.7.9 & Python 3.4 on Ubuntu 14.04 & Mac OS X        #
###########################################################################
import errno
import os
import signal
import socket

SERVER_ADDRESS = (HOST, PORT) = '', 8888
REQUEST_QUEUE_SIZE = 1024

def grim_reaper(signum, frame):
    pid, status = os.wait()

def handle_request(client_connection):
    request = client_connection.recv(1024)
    print(request.decode())
    http_response = b"""\
HTTP/1.1 200 OK

Hello, World!
"""
    client_connection.sendall(http_response)

def serve_forever():
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    listen_socket.bind(SERVER_ADDRESS)
    listen_socket.listen(REQUEST_QUEUE_SIZE)
    print('Serving HTTP on port {port} ...'.format(port=PORT))

    signal.signal(signal.SIGCHLD, grim_reaper)

    while True:
        try:
            client_connection, client_address = listen_socket.accept()
        except IOError as e:
            code, msg = e.args
            # restart 'accept' if it was interrupted
            if code == errno.EINTR:
                continue
            else:
                raise

        pid = os.fork()
        if pid == 0:  # child
            listen_socket.close()  # close child copy
            handle_request(client_connection)
            client_connection.close()
            os._exit(0)
        else:  # parent
            client_connection.close()  # close parent copy and loop over

if __name__ == '__main__':
    serve_forever()

$ python webserver3f.py

$ curl http://localhost:8888/hello

$ python client3.py --max-clients 128

$ ps auxw | grep -i python | grep -v grep

###########################################################################
# Concurrent server - webserver3g.py                                      #
#                                                                         #
# Tested with Python 2.7.9 & Python 3.4 on Ubuntu 14.04 & Mac OS X        #
###########################################################################
import errno
import os
import signal
import socket

SERVER_ADDRESS = (HOST, PORT) = '', 8888
REQUEST_QUEUE_SIZE = 1024

def grim_reaper(signum, frame):
    while True:
        try:
            pid, status = os.waitpid(
                -1,          # Wait for any child process
                 os.WNOHANG  # Do not block and return EWOULDBLOCK error
            )
        except OSError:
            return

        if pid == 0:  # no more zombies
            return

def handle_request(client_connection):
    request = client_connection.recv(1024)
    print(request.decode())
    http_response = b"""\
HTTP/1.1 200 OK

Hello, World!
"""
    client_connection.sendall(http_response)

def serve_forever():
    listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    listen_socket.bind(SERVER_ADDRESS)
    listen_socket.listen(REQUEST_QUEUE_SIZE)
    print('Serving HTTP on port {port} ...'.format(port=PORT))

    signal.signal(signal.SIGCHLD, grim_reaper)

    while True:
        try:
            client_connection, client_address = listen_socket.accept()
        except IOError as e:
            code, msg = e.args
            # restart 'accept' if it was interrupted
            if code == errno.EINTR:
                continue
            else:
                raise

        pid = os.fork()
        if pid == 0:  # child
            listen_socket.close()  # close child copy
            handle_request(client_connection)
            client_connection.close()
            os._exit(0)
        else:  # parent
            client_connection.close()  # close parent copy and loop over

if __name__ == '__main__':
    serve_forever()

$ python webserver3g.py

$ python client3.py --max-clients 128