Python 之网络式编程

一 客户端/服务器架构

即C/S架构，包括

1、硬件C/S架构（打印机）

2、软件B/S架构（web服务）

C/S架构与Socket的关系：

我们学习Socket就是为了完成C/S的开发

二 OSI七层

引子：　　

　　计算机组成原理：硬件、操作系统、应用软件三者组成。

　　具备以上条件后，计算机就可以工作，如果你要和别人一起玩，那你就需要上网了。互联网的核心就是由一堆协议组成，协议就是标准。

 

为什么学习Socket之前要先了解互联网协议？

　　1、C/S架构的软件（应用软件属于应用层）是基于网络进行通信的

　　2、网络的核心即一堆协议，协议即标准，想开发一款基于网络通信的软件，就必须遵循这些标准

OSI七层：

三 Socket层

四 Socket是什么 

　　Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口，在设计模式中，Socket其实就是一个门面模式，它把负责的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

　　所以，我们无需深入学习理解TCP/UDP协议，Socket已经为我们封装好了，我们只需要遵循Socket的规定去编程，写出的程序自然就是遵循TCP/UDP标准的。

五 套接字发展史及分类

　　套接字起源于20世纪70年代加利福尼亚大学伯克利分校版本的Unix，即人们所说的BSD Unix。因此，有时人们也把套接字成为“伯克利套接字”或“BSD套接字”。一开始，套接字被设计用在一台主机上多个应用程序之间的通信，这也被称作进程间通许或IPC。套接字有两种（或者称为两个种族），分别是基于文件型和就网络型。

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

　　UNIX一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器上，可以通过访问同一文件系统间接完成通信。

基于网络类型的套接字家族

套接字家族的名字：AF_INET

　　还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，Python支持很多地址家族，但是由于我们只关心网络编程，所以大部分时候我们只使用AF_INET(AF:Address Family;INET:Internet)

六 套接字工作流程

　　生活中，你要打电话给一个朋友，先拨号，朋友听到电话铃声响后接打电话，这时你和你的朋友就建立起了连接，就可以讲话了，等交流结束，挂断电话结束此次通话。

 利用Socket模拟生活中打电话：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket

phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买手机;socket.AF_INET:基于网络协议;socket.SOCK_STREAM:基于流的TCP协议
phone.bind(('127.0.0.1', 8080))  # 绑定手机卡;元祖形式，ip地址+端口
# 注：服务器的ip地址写本机的ip地址
phone.listen(5)  # 开机
conn, addr = phone.accept()  # 等电话
msg = conn.recv(1024)  # 收消息
print('客户端发来的消息是:', msg)
conn.send(msg.upper())  # 发消息
conn.close()
phone.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 买手机
phone.connect(('127.0.0.1', 8080))  # 拨电话
# 注：客户端的ip地址，写服务器端的ip地址
phone.send('hello'.encode('utf-8'))  # 发消息
data = phone.recv(1024)  # 收消息
print('收到服务端发来的消息', data)

服务器和客户端无限循环发送消息：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# import socket
from socket import *
import time
ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
print('服务端开始运行')
conn, addr = tcp_server.accept()  # 服务器阻塞
print('双向链接', conn)
print('客户端地址', addr)
while True:
    time.sleep(1)
    print('[%s]' % time.time())
    data = conn.recv(buffer_size)
    print('客户端发来的消息是', data.decode('utf-8'))
    conn.send(data.upper())
conn.close()
tcp_server.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from socket import *
import time
ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    time.sleep(2)
    print('[%s]' % time.time())
    msg = input('>>:').strip()
    tcp_client.send(msg.encode('utf-8'))
    print('客户端已经发送消息')
    data = tcp_client.recv(buffer_size)
    print('收到服务端发来消息', data.decode('utf-8'))
tcp_client.close()

Socket收发消息原理图：

若重启服务端时，可能会遇到：Address already in use;这个是由于服务端扔然存在四次挥手的time_wait状态占用地址

解决方案：

# 加入一条socket配置，重用ip和端口
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)  # <---就是这条，在bind前加
tcp_server.bind(ip_port)

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
vi /etc/sysctl.conf

编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
 
然后执行 /sbin/sysctl -p 让参数生效。
 
net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；

net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；

net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。

net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

七 基于UDP的套接字

udp服务端

ss = socket()  # 创建一个服务器的套接字
ss.bind()  # 绑定服务器套接字
while True:  # 服务器无限循环
    cs = ss.recvfrom()/ss.sendto()  # 对话（接收与发送）
ss.close()  #  关闭服务器套接字

udp客户端

cs = socket()  # 创建客户套接字
while True:
    cs.sendto()/cs.recvfrom()  # 对话（发送/接收）
cs.close()  # 关闭客户套接字

基于UDP的套接字：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from socket import *
ip_port = ('127.0.0.1', 8080)
buffer_size = 1024
udp_server = socket(AF_INET, SOCK_DGRAM)  # SOCK_DGRAM:数据报式套接字
udp_server.bind(ip_port)
while True:
    # data = udp_server.recvfrom(buffer_size)
    # print(data)  # (b'hello', ('127.0.0.1', 65047))
    data, addr = udp_server.recvfrom(buffer_size)
    print(data)
    print(addr)
    udp_server.sendto(data.upper(), addr)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from socket import *
ip_port = ('127.0.0.1', 8080)
buffer_size = 1024
udp_client = socket(AF_INET, SOCK_DGRAM)  # SOCK_DGRAM:数据报式套接字
while True:
    msg = input('>>').strip()
    udp_client.sendto(msg.encode('utf-8'), ip_port)
    data, addr = udp_client.recvfrom(buffer_size)
    print(data.decode('utf-8'))
    print(addr)

 八 什么是粘包？

注：只有TCP有粘包现象，UDP永远不会粘包

一个socket收发消息的原理图：

　　发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

　　例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

　　所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

　　此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

1. TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
2. UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
3. tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头

　　udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

　　tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

粘包解决方案：

方法一、

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from socket import *
import subprocess

ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
    conn, addr = tcp_server.accept()
    while True:
        try:
            cmd = conn.recv(buffer_size)
            # if not cmd:break
            # 执行命令，得到命令的运行结果cmd_res
            res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
                                   stderr=subprocess.PIPE,
                                   stdout=subprocess.PIPE,
                                   stdin=subprocess.PIPE
                                   )
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()
            if not cmd_res:
                cmd_res = 'excute success'.encode('utf-8')
            length = len(cmd_res)
            conn.send(str(length).encode('utf-8'))
            client_ready = conn.recv(buffer_size)
            if client_ready == b'ready':
                conn.send(cmd_res)

        except Exception as EX:
            print(EX)
            break
    conn.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from socket import *

ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    cmd = input('>>>').strip()
    if not cmd:continue
    if cmd == 'quit':break
    tcp_client.send(cmd.encode('utf-8'))
    length = tcp_client.recv(buffer_size)
    tcp_client.send(b'ready')
    length = int(length.decode('utf-8'))
    recv_size = 0
    recv_msg = b''
    while recv_size < length:
        # 第一种写法
        # r_m = tcp_client.recv(buffer_size)
        # recv_msg += r_m
        # recv_size += len(r_m)

        # 第二种写法
        recv_msg += tcp_client.recv(buffer_size)
        recv_size = len(recv_msg)
    print(recv_msg.decode('gbk'))
tcp_client.close()

方法二、

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from socket import *
import subprocess
import struct

ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
    conn, addr = tcp_server.accept()
    while True:
        try:
            cmd = conn.recv(buffer_size)
            # if not cmd:break
            # 执行命令，得到命令的运行结果cmd_res
            res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
                                   stderr=subprocess.PIPE,
                                   stdout=subprocess.PIPE,
                                   stdin=subprocess.PIPE
                                   )
            err = res.stderr.read()
            if err:
                cmd_res = err
            else:
                cmd_res = res.stdout.read()
            if not cmd_res:
                cmd_res = 'excute success'.encode('utf-8')
            length = len(cmd_res)
            data_length = struct.pack('i', length)
            conn.send(data_length)
            conn.send(cmd_res)

        except Exception as EX:
            print(EX)
            break
    conn.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from socket import *
import struct

ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    cmd = input('>>>').strip()
    if not cmd:continue
    if cmd == 'quit':break
    tcp_client.send(cmd.encode('utf-8'))
    length_data = tcp_client.recv(4)
    length = struct.unpack('i', length_data)[0]
    recv_size = 0
    recv_msg = b''
    while recv_size < length:
        # 第一种写法
        # r_m = tcp_client.recv(buffer_size)
        # recv_msg += r_m
        # recv_size += len(r_m)

        # 第二种写法
        recv_msg += tcp_client.recv(buffer_size)
        recv_size = len(recv_msg)
    print(recv_msg.decode('gbk'))
tcp_client.close()

 九 利用socketserver实现并发

基于TCP服务端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socketserver


class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        print('conn is:', self.request)  # <==>conn
        print('addr is:', self.client_address)  # <==> addr
        while True:
            try:
                # 收消息
                data = self.request.recv(1024)
                if not data:break
                print('收到客户端的消息是', data)
                # 发消息
                self.request.sendall(data.upper())
            except Exception as EX:
                print('错误提示:',EX)
                break


if __name__ == '__main__':
    s = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyServer)  # 多线程;第一个参数，地址+端口；第二个参数，类
25　　　# s = socketserver.ForkingTCPServer(('127.0.0.1', 8080), MyServer)  # 多进程；多进程的开销大于多线程
    s.serve_forever()

基于TCP客户端:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from socket import *
ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    msg = input('>>').strip()
    if not msg:continue
    if msg == 'quit':break
    tcp_client.send(msg.encode('utf-8'))
    data = tcp_client.recv(buffer_size)
    print('收到服务端发来的消息:', data.decode('utf-8'))
tcp_client.close()

基于UDP服务端 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socketserver


class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        print('收到客户端的消息是:', self.request[0].upper())
        self.request[1].sendto(self.request[0].upper(), self.client_address)


if __name__ == '__main__':
    s = socketserver.ThreadingUDPServer(('127.0.0.1', 8080), MyServer)  # 第一个参数，地址+端口；第二个参数，类
    s.serve_forever()

基于UDP客户端

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from socket import *
ip_port = ('127.0.0.1', 8080)
buffer_size = 1024
udp_client = socket(AF_INET, SOCK_DGRAM)  # SOCK_DGRAM:数据报式套接字
while True:
    msg = input('>>').strip()
    udp_client.sendto(msg.encode('utf-8'), ip_port)
    data, addr = udp_client.recvfrom(buffer_size)
    print(data.decode('utf-8'))
    print(addr)

 十 认证客户端的合法性

　　如果想在分布式系统中实现一个简单的客户端链接认证功能，又不像SSL那么复杂，那么可以利用hmac+加盐的方法来实现。

# _*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *
import hmac, os

secret_key = b'alex bang bang bang'


def conn_auth(conn):
    '''
    认证客户端链接
    :param conn:
    :return:
    '''
    print('开始验证新链接的合法性')
    msg = os.urandom(32)  # 随机生成的;b'\xa3\x9d\xaa\x94\x9e\x89\xe9\xc9\xc3r\xf9E\xe0w\x82=\xaac-\x04\xd8:\xea\x07\xad\x1dx\x1er\xe0\x7f\x02'
    conn.sendall(msg)
    h = hmac.new(secret_key, msg)  # <hmac.HMAC object at 0x000000D5DA4824E0>
    digest = h.digest()  # 随机生成的;b'\x17!*\xae6\x81\xfe|)\x138\xfa2o%\x1a'
    respone = conn.recv(len(digest))
    return hmac.compare_digest(respone, digest)  # 比较第一个参数和第二个参数；相同，返回True，反之也成立


def data_handler(conn, bufsize=1024):
    if not conn_auth(conn):
        print('该链接不合法,关闭')
        conn.close()
        return
    print('链接合法,开始通信')
    while True:
        data = conn.recv(bufsize)
        if not data: break
        conn.sendall(data.upper())


def server_handler(ip_port, bufsize, backlog=5):
    '''
    只处理链接
    :param ip_port:
    :return:
    '''
    tcp_socket_server = socket(AF_INET, SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
    while True:
        conn, addr = tcp_socket_server.accept()
        print('新连接[%s:%s]' % (addr[0], addr[1]))
        data_handler(conn, bufsize)


if __name__ == '__main__':
    ip_port = ('127.0.0.1', 9999)
    bufsize = 1024
    server_handler(ip_port, bufsize)

# _*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *
import hmac, os

secret_key = b'alex bang bang bang'


def conn_auth(conn):
    '''
    认证客户端链接
    :param conn:
    :return:
    '''
    print('开始验证新链接的合法性')
    msg = os.urandom(32)
    conn.sendall(msg)
    h = hmac.new(secret_key, msg)
    digest = h.digest()
    respone = conn.recv(len(digest))
    return hmac.compare_digest(respone, digest)


def data_handler(conn, bufsize=1024):
    if not conn_auth(conn):
        print('该链接不合法,关闭')
        conn.close()
        return
    print('链接合法,开始通信')
    while True:
        data = conn.recv(bufsize)
        if not data: break
        conn.sendall(data.upper())


def server_handler(ip_port, bufsize, backlog=5):
    '''
    只处理链接
    :param ip_port:
    :return:
    '''
    tcp_socket_server = socket(AF_INET, SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
    while True:
        conn, addr = tcp_socket_server.accept()
        print('新连接[%s:%s]' % (addr[0], addr[1]))
        data_handler(conn, bufsize)


if __name__ == '__main__':
    ip_port = ('127.0.0.1', 9999)
    bufsize = 1024
    server_handler(ip_port, bufsize)

 十一 FTP服务器

实现如下功能：

　　1、用户加密认证

　　2、每个用户都有自己的家目录，且只能访问自己的家目录

　　3、允许用户在ftp server上随意切换目录(cd)

　　4、允许用户查看当前目录下的所有文件(ls)

　　5、允许上传和下载文件

　　6、文件传输过程中显示进度条

　　7、支持文件的断点续传

ftp server

目录结构：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os,sys
PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(PATH)


from core import main


if __name__ == '__main__':
    main.ArgvHandler()

[DEFAULT]

[alex]
Password =123
Quotation = 100

[root]
Password = root
Quotation = 100

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

ip = '127.0.0.1'
port = 8080

ACCOUNT_PATH = os.path.join(BASE_DIR, 'conf', 'accounts.cfg')

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socketserver
import optparse
import socketserver
from conf import settings
from core import server


class ArgvHandler():
    def __init__(self):
        self.op = optparse.OptionParser()
        # self.op.add_option('-s', '--server', dest='server')
        # self.op.add_option('-P', '--port', dest='port')
        options, args = self.op.parse_args()
        # print(options)  # {'server': '127.0.0.1', 'port': '8080'}
        # print(type(options))  # <class 'optparse.Values'>
        # print(options.server)  # 127.0.0.1
        # print(args)

        options, args = self.op.parse_args()
        self.verify_args(options, args)

    def verify_args(self, options, args):
        cmd = args[0]
        # 第一种方法
        # if cmd == 'start':
        #     pass
        # else:
        #     pass
        # 第二种方法
        if hasattr(self, cmd):
            func = getattr(self, cmd)
            func()

    def start(self):
        print('ths server is working...')
        s = socketserver.ThreadingTCPServer((settings.ip, settings.port), server.ServerHandler)
        s.serve_forever()

    def help(self):
        pass

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socketserver
import json
import configparser
from conf import settings
import os

STATUS_CODE = {
    250: "Invalid cmd format,e.g:{'action':'get','filename':'test.py','size':344}",
    251: "Invalid cmd",
    252: "Invalid auth data",
    253: "Wrong username or password",
    254: "Passed authentication",
    255: "Filename doesn't provided",
    256: "File doesn't exist on server",
    257: "ready to send file",
    258: "md5 verification",
    800: "the file exist,but not enough,is continue?",
    801: "the file exist!",
    802: "ready to receive datas",
    900: "md5 valdate success"
}


class ServerHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            data = self.request.recv(1024).strip()  # self.request=conn
            data = json.loads(data.decode('utf8'))
            if data.get('action'):
                if hasattr(self, data.get('action')):
                    func = getattr(self, data.get('action'))
                    func(**data)
                else:
                    print('Invalid cmd')
            else:
                print('Invalid cmd')

    def send_response(self, status_code):
        response = {'status_code': status_code}
        self.request.sendall(json.dumps(response).encode('utf8'))

    def auth(self, **data):
        username = data['username']
        password = data['password']
        username = self.authenticate(username, password)
        if username:
            self.send_response(254)
        else:
            self.send_response(253)

    def authenticate(self, username, password):
        cfg = configparser.ConfigParser()
        cfg.read(settings.ACCOUNT_PATH)
        if username in cfg.sections():
            if cfg[username]['Password'] == password:
                self.username = username
                self.mainPath = os.path.join(settings.BASE_DIR, 'home', self.username)
                print('passed authenticate')
                return username

    def put(self, **data):
        print('data', data)
        file_name = data.get('file_name')
        file_size = data.get('file_size')
        target_path = data.get('target_path')
        abs_path = os.path.join(self.mainPath, target_path, file_name)
        has_received = 0
        if os.path.exists(abs_path):
            file_has_size = os.stat(abs_path).st_size
            if file_has_size < file_size:
                # 断点续传
                self.request.sendall('800'.encode('utf8'))
                choice = self.request.recv(1024).decode('utf8')
                if choice == 'Y':
                    self.request.sendall(str(file_has_size).encode('utf8'))
                    has_received = file_has_size
                    f = open(abs_path, 'ab')
                else:
                    f = open(abs_path, 'wb')
            else:
                # 文件完全存在
                self.request.sendall('801'.encode('utf8'))
                return
        else:
            self.request.sendall('802'.encode('utf8'))
            f = open(abs_path, 'wb')

        while has_received < file_size:
            try:
                data = self.request.recv(1024)
            except Exception as EX:
                break
            f.write(data)
            has_received += len(data)
        f.close()

    def ls(self, **data):
        file_list = os.listdir(self.mainPath)
        file_str = '\n'.join(file_list)
        if not len(file_list):
            file_str = '<empty dir>'
        self.request.sendall(file_str.encode('utf8'))

    def cd(self, **data):
        dirname = data.get('dirname')
        if dirname == '..':
            self.mainPath = os.path.dirname(self.mainPath)
        else:
            self.mainPath = os.path.join(self.mainPath, dirname)
        self.request.sendall(self.mainPath.encode('utf8'))

    def mkdir(self, **data):
        dirname = data.get('dirname')
        path = os.path.join(self.mainPath, dirname)
        if not os.path.exists(path):
            if '/' in path:
                os.makedirs(path)
            else:
                os.mkdir(path)
            self.request.sendall('create success'.encode('utf8'))
        else:
            self.request.sendall('dirname exist'.encode('utf8'))

ftp client

目录结构

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# import socket
#
# sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# sk.connect(('127.0.0.1', 8080))
import optparse
import socket
import json
import os, sys
STATUS_CODE = {
    250: "Invalid cmd format,e.g:{'action':'get','filename':'test.py','size':344}",
    251: "Invalid cmd",
    252: "Invalid auth data",
    253: "Wrong username or password",
    254: "Passed authentication",
    255: "Filename doesn't provided",
    256: "File doesn't exist on server",
    257: "ready to send file",
    258: "md5 verification",
    800: "the file exist,but not enough,is continue?",
    801: "the file exist!",
    802: "ready to receive datas",
    900: "md5 valdate success"
}


class ClientHandler(object):
    def __init__(self):
        self.op = optparse.OptionParser()
        self.op.add_option('-s', '--server', dest='server')
        self.op.add_option('-P', '--port', dest='port')
        self.op.add_option('-u', '--username', dest='username')
        self.op.add_option('-p', '--password', dest='password')

        self.options, self.args = self.op.parse_args()

        self.verify_args(self.options, self.args)
        self.make_connection()
        self.mainPath = os.path.dirname(os.path.abspath(__file__))
        self.last = 0

    def verify_args(self, options, args):
        server = options.server
        port = options.port
        username = options.username
        password = options.password
        if int(port) > 0 and int(port) < 65535:
            return True
        else:
            exit('the port is in 0-65535')

    def make_connection(self):
        self.sock = socket.socket()
        self.sock.connect((self.options.server, int(self.options.port)))

    def interactive(self):
        print('begin to interactive...')
        # self.authenticate()
        if self.authenticate():
            while 1:
                cmd_info = input('[%s]' % self.current_dir).strip()
                cmd_list = cmd_info.split()
                if hasattr(self, cmd_list[0]):
                    func = getattr(self, cmd_list[0])
                    func(*cmd_list)

    def put(self, *cmd_list):
        # put 12.png images
        actions, local_path, target_path = cmd_list
        local_path = os.path.join(self.mainPath, local_path)
        file_name = os.path.basename(local_path)
        file_size = os.stat(local_path).st_size
        data = {
            'action': 'put',
            'file_name': file_name,
            'file_size': file_size,
            'target_path': target_path
        }
        self.sock.send(json.dumps(data).encode('utf8'))
        is_exist = self.sock.recv(1024).decode('utf8')
        has_send = 0
        if is_exist == '800':
            # 文件不完整
            choice = input('the file exist,but not enough,is continue?[Y/N]').strip()
            if choice.upper() == 'Y':
                self.sock.sendall('Y'.encode('utf8'))
                continue_position = self.sock.recv(1024).decode('utf8')
                has_send += int(continue_position)
            else:
                self.sock.sendall('N'.encode('utf8'))
        elif is_exist == '801':
            # 文件完全存在
            print('the file exist')
            return
        else:
            pass
        f = open(local_path, 'rb')
        f.seek(has_send)
        while has_send < file_size:
            data = f.read(1024)
            self.sock.sendall(data)
            has_send += len(data)
            self.show_progress(has_send, file_size)
        f.close()
        print('successfully upload!')

    def show_progress(self, has, total):
        rate = float(has)/float(total)
        rate_num = int(rate*100)
        if self.last != rate_num:
            sys.stdout.write('%s%% %s\r' % (rate_num, '#'*rate_num))
        self.last = rate_num

    def ls(self, *cmd_list):
        data = {
            'action': 'ls'
        }
        self.sock.sendall(json.dumps(data).encode('utf8'))
        data = self.sock.recv(1024).decode('utf8')
        print(data)

    def cd(self, *cmd_list):
        data = {
            'action': 'cd',
            'dirname': cmd_list[1]
        }
        self.sock.sendall(json.dumps(data).encode('utf8'))
        data = self.sock.recv(1024).decode('utf8')
        self.current_dir = os.path.basename(data)

    def mkdir(self, *cmd_list):
        data = {
            'action': 'mkdir',
            'dirname': cmd_list[1]
        }
        self.sock.sendall(json.dumps(data).encode('utf8'))
        data = self.sock.recv(1024).decode('utf8')

    def authenticate(self):
        if self.options.username is None or self.options.password is None:
            username = input('username:')
            password = input('password:')
            return self.get_auth_result(username, password)
        return self.get_auth_result(self.options.username, self.options.password)

    def response(self):
        data = self.sock.recv(1024).decode('utf8')
        data = json.loads(data)
        return data

    def get_auth_result(self, username, password):
        data = {
            'action': "auth",
            'username': username,
            'password': password
        }
        self.sock.send(json.dumps(data).encode('utf8'))
        response = self.response()
        print('response:', response['status_code'])
        if response['status_code'] == 254:
            self.username = username
            self.current_dir = username
            print(STATUS_CODE[response['status_code']])
            return True
        else:
            print(STATUS_CODE[response['status_code']])


ch = ClientHandler()
ch.interactive()

 十二 进程与线程

1、为什么要有操作系统？

　　现代计算机系统是由一个或者多个处理器、内存、硬盘、打印机、键盘、鼠标和显示器等组成的。网络接口以及各种其他输入/输出设备组成的复杂系统，每位程序员不可能掌握所有系统实现的细节，并且管理优化这些部件是一件具有挑战性极强的工作。所以，我们需要为计算机安装一层软件，成为操作系统，任务就是用户程序性提供一个简单清晰的计算机模型，并管理以上设备。

　　定义：操作系统是一个用来协调、管理和控制计算机硬件和软件资源的系统程序，它位于硬件和应用程序之间。程序是运行在系统上的具有某种功能的软件，比如：浏览器，音乐播放器等。

　　操作系统内部的定义：操作系统的内核是一个管理和控制程序，负责管理计算机的所有物理资源，其中包括：文件系统、内存管理、设备管理、进程管理。

2、什么是进程？

　　假如有两个程序A和B，程序A在执行到一半的过程中，需要读取大量的数据输入(I/O操作)，而此时CPU只能静静地等待任务A读取完数据才能继续执行，这样就白白浪费了CPU资源。是不是在程序A读取数据的过程中，让程序B去执行，当程序A读取完数据之后，让程序B暂停，然后让程序A继续执行？当然没问题，但这里有一个关键词：切换；既然是切换，那么这就涉及到了状态的保存，状态的恢复，加上程序A与程序B所需要的系统资源(内存，硬盘，键盘等等)是不一样的。自然而然的就需要有一个东西去记录程序A和程序B分别需要什么资源，怎样去识别程序A和程序B等等，所以就有了一个叫进程的抽象。

定义：

　　进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据库、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成。数据集则是程序在执行过程中所需要使用的资源。进程控制块用来记录的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。

　　本质上就是一段程序的运行过程（抽象的概念）

3、什么是线程？

　　线程的出现是为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一样事的缺陷，让进程内并发成为可能。

4、进程与线程区别

1、一个程序至少有一个进程，一个进程至少有一个线程（进程可以理解成线程的容器）

2、进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率

3、线程在执行过程中与进程还是有区别的，每个独立的线程有一个程序运行的入口，顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

4、进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位；线程是进程的一个实体，是CPU调度和分源的基本单位，它是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源，只拥有一点运行中必不可少的资源（如程序计数器，一组寄存器和钱），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。一个进程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行。

5、线程：最小的执行单元（实例）；进程：最小的资源单位

5、Python的GIL(全局解释锁;Global Interpreter Lock)

　　In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

上面的核心意思：无论你启多少个线程，你有多少个CPU，Python在执行的时候会淡定的在同一时刻只允许一个线程运行。

6、 线程的两种调用方式

　　threading 模块建立在thread 模块之上。thread模块以低级、原始的方式来处理和控制线程，而threading 模块通过对thread进行二次封装，提供了更方便的api来处理线程。

调用方式：

方式一、

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time


def music():
    print('begin to listen % s' % time.ctime())
    time.sleep(3)
    print('stop to listen %s' % time.ctime())


def game():
    print('begin to play game % s \r\n' % time.ctime())
    time.sleep(5)
    print('stop to play game %s \r\n' % time.ctime())


threads = []
t1 = threading.Thread(target=music)
t2 = threading.Thread(target=game)
threads.append(t1)
threads.append(t2)
if __name__ == '__main__':
    # join()功能：在子线程完成运行之前，这个子线程的父线程讲一直被阻塞
    # t1 = threading.Thread(target=music)
    # t2 = threading.Thread(target=game)
    # t1.start()
    # t2.start()
    #
    # t1.join()
    # t2.join()
    # print('end')
    
    # setDaemon():将线程生命为守护线程
    t2.setDaemon(True)  # 注：一定要在start之前设置
    for t in threads:
        t.start()
    print('end')

方式二、

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time


class MyThread(threading.Thread):
    def __init__(self, num):
        threading.Thread.__init__(self)
        self.num = num

    def run(self):  # 定义每个线程要运行的函数

        print("running on number:%s" % self.num)

        time.sleep(3)


if __name__ == '__main__':
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()

    print("ending......")

join():在子线程完成运行之前，这个子线程的父线程将一直被阻塞。

setDaemon(True)：

　　将线程生命为守护线程，必须在start()方法调用之前设置，如果不设置为守护线程，程序会被无限挂起。这个方法基本和join是相反的。当我们在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程就分兵两路，分别运行，那么当主线程完成想退出时，会验证子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是，只要主线程完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以用setDaemon方法了。

 其他方法：

# run():用于表示线程活动的方法
# start():启动线程活动
# isAlive():返回线程是否活动的,返回布尔值,True/False
# getName():返回线程名字
# setName():设置线程名字

threading模块提供的一些方法:
# threading.currentThread():返回当前的线程变量
# threading.enumerate():返回一个包含正在运行的线程的list。正在运行指线程启动后-结束前，不包括启动前和终止后的线程
# threading.activeCount():返回正在运行的线程数量，与len(threading.enumerate())有相同的结果

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time


def music():
    print('begin to listen % s' % time.ctime())
    time.sleep(3)
    print('stop to listen %s' % time.ctime())


def game():
    print('begin to play game % s \r\n' % time.ctime())
    time.sleep(5)
    print('stop to play game %s \r\n' % time.ctime())


threads = []
t1 = threading.Thread(target=music)
t2 = threading.Thread(target=game)
threads.append(t1)
threads.append(t2)
if __name__ == '__main__':
    # join()功能：在子线程完成运行之前，这个子线程的父线程讲一直被阻塞
    # t1 = threading.Thread(target=music)
    # t2 = threading.Thread(target=game)
    # t1.start()
    # t2.start()
    #
    # t1.join()
    # t2.join()
    # print('end')

    # setDaemon():将线程生命为守护线程
    t2.setDaemon(True)  # 注：一定要在start之前设置
    for t in threads:
        t.start()
        print(t.getName())
        print('count:', threading.activeCount())
    while threading.activeCount() == 3:
        print('end')

7、同步锁(lock)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time
num = 100


def sub():
    global num
    print('ok')
    lock.acquire()  # 加锁
    temp = num
    time.sleep(0.001)
    num = temp-1
    lock.release()  # 释放锁


li = []
lock = threading.Lock()
for i in range(100):
    t1 = threading.Thread(target=sub)
    t1.start()
    li.append(t1)
for l in li:
    l.join()
print(num)

 注：多个线程都在同时操作同一个共享资源，所以造成了资源破坏(join会造成串行，失去线程的意义)，可以通过同步锁来解决这种问题。

8、递归锁

　　在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁，因为系统判断这部分资源都在使用，所有这两个线程在无外力作用下将一直等待下去。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time


class MyThread(threading.Thread):

    def actionA(self):
        r_lock.acquire()
        print(self.name, 'gotA', time.ctime())  # 重写线程后的self.name --->线程的名字
        time.sleep(2)
        r_lock.acquire()
        print(self.name, 'gotB', time.ctime())
        time.sleep(1)
        r_lock.release()
        r_lock.release()

    def actionB(self):
        r_lock.acquire()
        print(self.name, 'gotB', time.ctime())  # 重写线程后的self.name --->线程的名字
        time.sleep(2)
        r_lock.acquire()
        print(self.name, 'gotA', time.ctime())
        time.sleep(1)
        r_lock.release()
        r_lock.release()

    def run(self):
        self.actionA()
        self.actionB()


if __name__ == '__main__':
    r_lock = threading.RLock()
    li = []
    for t in range(3):
        t = MyThread()
        t.start()
        li.append(t)

    for i in li:
        i.join()

    print('end')

　　为了支持在同一线程中多次请求同一资源，Python提供了“可重入锁”：threading.Rlock。Rlock内部维护着一个Lock和counter变量，counter记录了acquire的次数，从而使得资源可以被多次acquire。直到一个线程所有的acquire都被release，其他的线程才能获得资源。

9、同步对象(Event)

An event is a simple synchronization object;the event represents an internal flag,

and threads can wait for the flag to be set, or set or clear the flag themselves.

event = threading.Event()

# a client thread can wait for the flag to be set
event.wait()

# a server thread can set or reset it
event.set()
event.clear()

If the flag is set, the wait method doesn’t do anything.
If the flag is cleared, wait will block until it becomes set again.
Any number of threads may wait for the same event.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time


class Boss(threading.Thread):
    def run(self):
        print('Boss:今天加班到22：00！\r\n')
        print(event.isSet())  # False
        event.set()
        time.sleep(6)
        print('Boss:可以下班了，明天放假！\r\n')
        print(event.isSet())
        event.set()


class Worker(threading.Thread):
    def run(self):
        event.wait()  # 一旦event被设定，等同于pass
        print('Worker:唉···命真苦！\r\n')
        time.sleep(1)
        event.clear()
        event.wait()
        print('Worker:OhYeah!\r\n')


if __name__ == '__main__':
    event = threading.Event()
    threads = []
    for i in range(5):
        threads.append(Worker())
    threads.append(Boss())
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    print('end')

10、信号量

　　信号量用来控制线程并发数的，BoundedSemaphore或Semaphore管理一个内置的计数器，每当调用acquire()时-1，调用release()时+1。计数器不能小于0，当计数器为0时，acquire()将阻塞线程至同步锁状态，直到其他线程调用release()。(类似于停车位的概念)BoundedSemaphore与Semaphore的唯一区别在于前者将在调用release()时检查计数器的值是否超过了计数器的初始值，如果超过了将抛出一个异常。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time


class MyThread(threading.Thread):
    def run(self):
        if semaphore.acquire():
            print(self.name, '\r')
            time.sleep(5)
            semaphore.release()


if __name__ == '__main__':
    semaphore = threading.Semaphore(5)
    threads = []
    for i in range(100):
        threads.append(MyThread())
    for t in threads:
        t.start()

 

11、队列(queue)

　　列表是不安全的数据结构：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time

li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def Foo():
    while li:
        try:
            last_li = li[-1]
            print(last_li)
            li.remove(last_li)
            time.sleep(1)
        except Exception as EX:
            print('错误提示:', last_li, EX)


t1 = threading.Thread(target=Foo)
t1.start()
t2 = threading.Thread(target=Foo)
t2.start()

　　queue队列类的方法：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import queue  # 线程队列
q = queue.Queue()  # 创建q对象,同步实现的。队列长度可为无限或者有限。可通过Queque的构造函数的可选参数maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限
q.put(12)  # 将一个值放到队列，调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；第二个block为可选参数，默认为1.如果队列当前为空且block为1，put()方法就使调用线程暂停，直到空处一个数据单元。如果block为0，put方法将引发Full异常
q.put('alex')
q.put({"age": 15})
print(q.get())  # 将一个值从队列中取出，调用队列对象的get()方法，从对头删除并返回一个实例。可选参数为block，默认为True。如果队列为空且block为True，get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常
print(q.qsize())  # 返回队列的大小
print(q.empty())  # 判断队列是否为空，返回布尔值，True/False
print(q.full())  # 判断队列是否已经满了，返回布尔值，True/False
q.join()  # 实际上意味着等到队列为空，再执行别的操作

'''
Queue模块的三种队列及构造函数
1、Python Queue模块的FIFO队列，先进先出 class queue.Queue(maxsize)
2、LIFO 类似于堆，即先进后处。  class queue.LifoQueue(maxsize)
3、优先级队列，级别越低月先出来。 class queue.PriorityQueue(maxsize)
'''

生产者消费者模型

为什么要使用生产者和消费者模式？

　　在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式？

　　生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import random
import queue
import threading
q = queue.Queue()


def Producer(name):
    count = 0
    while count < 10:
        print('making..')
        time.sleep(random.randrange(3))
        q.put(count)
        print('Producer [%s] has produced %s meat bun。\r' % (name, count))
        count += 1
        print('ok\r')


def Consumer(name):
    count = 0
    while count < 10:
        time.sleep(random.randrange(4))
        if not q.empty():
            data = q.get()
            print('lm Consumer [%s] has eat %s meat bun。\r' % (name, data))
        else:
            print('---no meat bun anymore----\r')
        count += 1


p1 = threading.Thread(target=Producer, args=('alex',))
c1 = threading.Thread(target=Consumer, args=('B',))
p1.start()
c1.start()

12、并发&并行

　　并发：指系统具有处理多个任务(动作)的能力

　　并行：指系统具有同时处理多个任务(动作)的能力

13、同步&异步

　　同步：当进程执行到一个IO(等待外部数据)的时候你等

　　异步：当进程执行到一个IO(等待外部数据)的时候你不等；一直等到数据接收完成，在回来处理

14、任务类型

　　IO密集型：Python的多线程是有意义的

　　计算密集型：Python的多线程就不推荐，可以采用多进程+协程

 16、多进程模块( multiprocessing)

Multiprocessing is a package that supports spawning processes using an API similar to the threading module. The multiprocessing package offers both local and remote concurrency,effectively side-stepping the Global Interpreter Lock by using subprocesses instead of threads. Due to this, the multiprocessing module allows the programmer to fully leverage multiple processors on a given machine. It runs on both Unix and Windows.

　　由于GIL的存在，Python中的多线程其实并不是真正的多线程，如果想充分地使用多核CPU的资源，在Python中大部分情况下需要使用多进程。multiprocessing包是Python中的多进程管理包。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法，也有start()，run()，join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类(这些对象可以像多线程那样，通过参数传递给各个进程)，用以同步进程，其用法与threading包中的同名类一致。所以，multiprocessing的很大一部分与threading使用同一套API，只不过换到了多进程的情景。

 调用方式一：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process
import time


def Foo(name):
    time.sleep(1)
    print('hello', name, time.ctime())


if __name__ == '__main__':
    p_list = []
    for i in range(200):
        p = Process(target=Foo, args=('alex',))
        p_list.append(p)
        p.start()
    for i in p_list:
        p.join()
    print('end')

调用方式二：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process
import time


class MyProcess(Process):
    def __init__(self):
        super(MyProcess, self).__init__()

    def run(self):
        time.sleep(1)
        print('hello', self.name, time.ctime())


if __name__ == '__main__':
    p_list = []
    for i in range(3):
        p = MyProcess()
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print('end')

Process类 

构造方法：

Process([group [, target [, name [, args [, kwargs]]]]])

　　group:线程组，目前还没有实现，库引用中提示必须是None

　　target:要执行的方法

　　name:进程名

　　args/kwargs:要传入方法的参数

实例方法：

　　is_alive():返回进程是否在运行

　　join([timeout]):阻塞当前上下文环境的进程，直到调用此方法的进程终止或到达指定的timeout(可选参数)

　　start():进程准备就绪，等待CPU调度

　　run():start()调用run方法，如果实例进程时未指定传入target，这start执行t默认run()方法

　　terminate():不管任务是否完成，立即停止工作进程

属性：

　　daemon:和线程的setDeamon功能一样

　　name:进程名字

　　pid:进程号

17、进程的通信

进程队列Queue

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import queue
import multiprocessing


def Foo(q):
    q.put(123)
    q.put(456)


if __name__ == '__main__':
    q = multiprocessing.Queue()  # 注意：此处需用进程队列，不能用线程队列，即q=queue.Queue()
    p = multiprocessing.Process(target=Foo, args=(q,))
    p.start()
    print(q.get())
    print(q.get())

 管道

The Pipe() function returns a pair of connection objects connected by a pipe which by default is duplex (two-way). For example:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process, Pipe


def Foo(child_conn):
    child_conn.send([12, {'name': 'alice'}, 'hello'])
    response = child_conn.recv()
    print('response:', response)
    child_conn.close()
    print('q_id2:', id(child_conn))


if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    print('q_ID1', id(child_conn))
    p = Process(target=Foo, args=(child_conn,))
    p.start()
    print(parent_conn.recv())
    parent_conn.send('早上好!')
    p.join()

Managers

Queue和pipe只是实现了数据交互，并没实现数据共享，即一个进程去更改另一个进程的数据。

A manager object returned by Manager() controls a server process which holds Python objects and allows other processes to manipulate them using proxies.

A manager returned by Manager() will support types list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array. For example：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process, Manager


def Foo(dic, li, i):
    dic[i] = '1'
    li.append(i)


if __name__ == '__main__':
    with Manager() as manager:
        dic = manager.dict()
        li = manager.list(range(5))
        p_list = []
        for i in range(10):
            p = Process(target=Foo, args=(dic, li, i))
            p.start()
            p_list.append(p)
        for p in p_list:
            p.join()
        print(dic)
        print(li)

 进程同步

Without using the lock output from the different processes is liable to get all mixed up.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process, Lock


def Foo(lk, i):
    with lk:  # 默认情况下，已经lk.acquire()
        print('hello world %s' % i)


if __name__ == '__main__':
    lock = Lock()
    for num in range(10):
        Process(target=Foo, args=(lock, num)).start()

进程池

　　进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可进程为止。

进程池中两个方法：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import time, os


def Foo(i):
    time.sleep(1)
    print('i = \r', i)


def Bar(arg):  # 此处arg=Foo()函数的返回值
    print('pgid-->%s\r' % os.getpid())
    print('ppid-->%s\r' % os.getppid())
    print('logger:%s\r' % arg)


if __name__ == '__main__':
    pool = Pool(5)
    Bar(1)
    print('------------\r')
    for i in range(10):
        # pool.apply(func=Foo, args=(i,))  # 同步接口
        # pool.apply_async(func=Foo, args=(i,))
        pool.apply_async(func=Foo, args=(i,), callback=Bar)  # callback-->回调函数：就是某个动作或者函数执行成功后再去执行的函数

 pool.close() 27 pool.join() # join和close位置不能反 28 print('end\r')

 十三 协程

　　协程：又称微线程，英文名：Coroutine，本质上是一个线程

　　优点1：协程具有极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制。因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

　　优点2：不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

　　因为协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法就是多进程+协程，即充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time


def consumer(name):
    print('---->ready to eat meat bun')
    while True:
        new_meat_bun = yield
        print('[%s] is eating meat bun %s' % (name, new_meat_bun))


def producer():
    con1.__next__()
    con2.__next__()
    n = 0
    while 1:
        time.sleep(1)
        print('\033[32;1m[producer]\033[0m is making meat bun %s and %s' % (n, n + 1))
        con1.send(n)
        con2.send(n + 1)
        n += 2


if __name__ == '__main__':
    con1 = consumer('alex')
    con2 = consumer('alice')
    producer()

 Greenlet

　　greenlet是一个用C实现的协程模块，相比与Python自带的yield，它可以使你在任意函数之间随意切换，而不需把这个函数先声明为generator。(注：需要用pip安装包;pip install gevent)

from greenlet import greenlet
import time


def A():
    while 1:
        print('-------A-------')
        time.sleep(0.5)
        g2.switch()


def B():
    while 1:
        print('-------B-------')
        time.sleep(0.5)
        g1.switch()


g1 = greenlet(A)  # 创建协程g1
g2 = greenlet(B)

g1.switch()  # 跳转至协程g1

 gevent

import gevent
import requests, time  # 此处requests需安装模块;pip --timeout=100 install requests

start = time.time()


def f(url):
    print('GET: %s' % url)
    resp = requests.get(url)  # 爬网页的标签
    data = resp.text
    print('%d bytes received from %s.' % (len(data), url))


gevent.joinall([
    gevent.spawn(f, 'https://www.qq.com/'),
    gevent.spawn(f, 'https://www.baidu.com/'),
    gevent.spawn(f, 'https://www.taobao.com/'),
])

print("cost time:", time.time() - start)

 十四 缓存I/O

　　缓存I/O又被称作标准I/O，大多数文件系统的默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中，操作系统会将I/O的数据缓存在文件系统的页缓存(page cache)中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内的缓冲区拷贝到应用程序的地址空间。用户空间没法直接访问内核空间的，内核态到用户态的数据拷贝。

　　缓存I/O的缺点：数据在传输过程中需要在应用程序地址空间和内核进行多次数据拷贝操作，这些数据拷贝操作所带来的CPU以及内存开销是非常大的。

I/O发生时设计的对象和步骤：

　　对于一个network IO（以read举例），他会涉及到两个系统对象，一个是调用这个IO的process(or thread)，另一个就是系统内核(kernel)。当一个read操作发生时，它会经历两个阶段：

　　　　1、等待数据准备(Waiting for the data to be read)

　　　　2、将数据从内核拷贝到进程中(Copying the data from the kernel to the process)

注：这两点很重要，因为这些IO Mode的区别就是在这两个阶段上各有不同的情况。

blocking IO(阻塞IO，Linux下)

　　在Linux中，默认情况下所有的socket都是blocking，一个典型的读操作大概流程图：

　　当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一阶段:准备数据。对于network IO来说，很多时候数据在一开始还没到达(如：还没收到一个完整的UDP包)，这个时候kernel就要等待足够的数据到来。而在用户进程这边，整个进程会被阻塞。当kernel一直等到数据准备好了，它就将数据从kernel中拷贝到用户内存，然后kernel。所以，blocking IO的特点就是在IO执行的两个阶段都被block了。

non-blocking IO(非阻塞IO,Linux下)

　　在Linux下，可以通过设置socket使其变为non-blocking。当对一个non-blocking socket执行时大概的流程:

从上图可以看出，当用户进程发出read时，如果kernel中的数据还没准备好，那么它并不会block用户进程，而是立即返回一个error。从用户进程角度讲来讲，它发起一个read操作后，并不需要等待，而是马上就得到了一个结果。用户进程判断结果是一个error时，它就知道数据还没准备好，于是它可以再次发送read操作。一旦kernel中的数据准备好了。所以，用户进程其实是需要不断的主动询问kernel数据好了没有。

import time
import socket
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.bind(('127.0.0.1',8080))
sk.listen(5)
sk.setblocking(False)  # 设置是否阻塞,默认为True，非阻塞
while True:
    try:
        print('waiting client connection...')
        conn,addr = sk.accept()  # 进程主动轮询
        print('+++',addr)
        data = sk.recv(1024)
        print(str(data,'utf8'))
        conn.close()
    except Exception as EX:
        print('错误提示:',EX)
        time.sleep(2)

import time
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
while True:
    sk.connect(('127.0.0.1',8080))
    print('hello')
    sk.sendall(bytes('hello','utf8'))
    time.sleep(1)
    break

 IO multiplexing(IO多路复用)

　　有些地方也称为这种IO方式为event driven IO。它的基本原理就是select/epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程，大概流程图：

　　当用户进程调用了select，那么真个进程会被block。而同时，kernel会“监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这时用户进程再调用read操作，将数据从kernel拷贝到用户进程。(如果处理的连接数不是很多的话，使用select/epoll的web server不一定比使用multi-threading+blocking IO的web server性能更好，可能延迟更大；select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接)

注：

　　1、select函数返回结果中如果有文件可读了，那么进程就可以同故宫调用accept()或recv()来让kernel将位于内核中准备到的数据copy到用户区。

　　2、select的优势在于可以处理多个连接，不适用于单个连接。

import socket
import select

sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.bind(('127.0.0.1', 8080))
sk.listen(5)
inputs = [sk, ]
while True:
    r, w, e = select.select(inputs, [], [], 3)
    for obj in r:
        print('obj:', obj)
        if obj == sk:
            conn, addr = obj.accept()
            print('已连接：', conn)
            inputs.append(conn)
        else:
            data_byte = obj.recv(1024)
            print(str(data_byte, 'utf8'))
            inp = input('回答[%s]号客户端>>:' % inputs.index(obj))
            obj.sendall(bytes(inp, 'utf8'))
    print('>>>', r)

import socket

sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.connect(('127.0.0.1', 8080))

while True:
    inp = input(">>>>")
    sk.sendall(bytes(inp, "utf8"))
    data = sk.recv(1024)
    print(str(data, 'utf8'))

 Asynchronous I/O(异步IO)

　　流程图：

　　从图中可以看出，用户进程发起read操作之后，立刻就开始去做其它的事。另一方面，从kernel的角度，当他受到一个asynchronous read之后，首先它会立刻返回，所以不会对用户进程产生任何block。然后，kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel会给用户进程发送一个signal，告诉它read操作完成了。

selectors模块：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import selectors
import socket

sel = selectors.DefaultSelector()  # 根据系统，默认选择最优IO多用户模式


def accept(sock, mask):
    conn, addr = sock.accept()
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)


def read(conn, mask):
    try:
        data = conn.recv(1000)
        if not data:
            raise Exception
        print('收到:', data.decode('utf8'))
        conn.send(data.upper())  # Hope it won't block
    except Exception as EX:
        print('closing:', conn)
        sel.unregister(conn)  # 解除绑定
        conn.close()


sock = socket.socket()
sock.bind(('localhost', 8080))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)  # sock与accept绑定
while True:
    events = sel.select()  # 监听[sock,conn1,conn2....]
    for key, mask in events:
        callback = key.data
        print('>>callback:', callback)
        callback(key.fileobj, mask)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
sk = socket.socket()
sk.connect(('127.0.0.1', 8080))
while True:
    inp = input('>>>')
    sk.send(inp.encode('utf8'))
    data = sk.recv(1024)
    print(data.decode('utf8'))