Different types Server in Python

multiprocess(The almost same as threading)

from socket import *
from multiprocessing import *
from time import sleep

def dealWithClient(newsocket,cAddr):
    while True:
        recvData = newsocket.recv(1024)
        if len(recvData)>0:
            print('----recv from %s ----  %s'%(str(cAddr),recvData))
        else:
            print('The client is closed')
            break
    newsocket.close()


def main():
    sSocket = socket(AF_INET,SOCK_STREAM)
    Addr = ('',7788)
    sSocket.bind(Addr)
    sSocket.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
    sSocket.listen()
    try:
        while True:
            print('The server is waiting the client---')
            newSocket,cAddr = sSocket.accept()
            #replace the Process with Thread to convert it into multi thread
            client = Process(target=dealWithClient,args=(newSocket,cAddr))
            client.start()
            newSocket.close()
    finally:
        sSocket.close()

if __name__ == '__main__':
    main()

single process with no blocking

from socket import *
import time

#store all the connection still alive
g_socketList = []

def main():
    serSocket = socket(AF_INET,SOCK_STREAM)
    Addr = ('',7788)
    serSocket.bind(Addr)
    serSocket.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
    serSocket.listen()

    #set the server into unblocking to achieve multiple task solving
    serSocket.setblocking(False)

    while True:
        time.sleep(0.5)

        try:
            #if no client connect to server it will throws exceptions
            newClient = serSocket.accept()
        except Exception as result:
            pass
        else:
            g_socketList.append(newClient)
            print('---A new client connect to the server now ----%s'%str(newClient))
            newClient[0].setblocking(False)

        for clien,cAddr in g_socketList:
            try:
                recvData =clien.recv(1024)
                if len(recvData)>0:
                    print('Recv(%s)from(%s)'%(str(recvData),str(cAddr)))
                else:
                    print('---client %s is closed---'%str(cAddr))
                    clien.close()
                    g_socketList.remove((clien,cAddr))
            except Exception as result:
                pass

if __name__ == "__main__":
    main()

select echo server
shortcoming:The client concurrent amount is small,1024(32bit machine)/2048(64 bit machine)

import select
from socket import *
import sys

server  = socket(AF_INET,SOCK_STREAM)
server.bind(('',7788))
server.listen()
inputs = [server,sys.stdin]
running = True

while True:
    readable,writeable,exceptional = select.select(inputs,[],[])

    for sock in readable:
        if sock == server:
            conn , addr = server.accept()
            inputs.append(conn)
        elif sock == sys.stdin:
            cmd = sys.stdin.readline()
            running = False
            break
        else:
            data = sock.recv(1024)
            if data:
                sock.send(data)
            else:
                inputs.remove(sock)
                sock.close()

    if not running:
        break

server.close()

epoll version server
Compared to select,it has no limit on the number of concurrent client

from socket import *
import select
s = socket(AF_INET,SOCK_STREAM)
s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
s.bind(('',7788))
s.listen(10)

#create a epoll object
epoll = select.epoll()
#fileno is file descriptor
epoll.register(s.fileno(),select.EPOLLIN|select.EPOLLET)

connections = {}
address = {}

while True:
    #process fd scanning
    epoll_list = epoll.poll()

    for fd,events in epoll_list:
        if fd == s.fileno():
            conn,addr = s.accept()
            print('A new client is coming~ %s'%str(addr))

            connections[conn.fileno()] = conn
            address[conn.fileno()]  = addr

            epoll.register(conn.fileno(),select.EPOLLET|select.EPOLLIN)
        elif events == select.EPOLLIN:
            recvData = connections[fd].recv(1024)
            if len(recvData)>0:
                print('recv %s'%recvData)
        else:
            epoll.unregister(fd)
            connections[fd].close()
            print('----%s---offline----'%str(address[fd]))

Association(gevent) version server

import sys
import time
import gevent

from gevent import socket,monkey
monkey.patch_all()

def handle_request(conn):
    while True:
        data = conn.recv(1024)
        if not data:
            conn.close()
            break
        else:
            print('recv:',data)
            conn.send(data)

def server(port):
    s = socket.socket()
    s.bind(('',port))
    s.listen(5)
    while True:
        cli,addr = s.accept()
        gevent.spawn(handle_request,cli)

if __name__=='__main__':
    server(7788)