一、socket服务端实现并发
服务端：
import socket
from threading import Thread
"""
服务端：
    1、固定的ip和port
    2、24小时不间断提供服务
    3、支持高并发
"""

server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)          # 半连接池


def communicate(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0:break
            print(data)
            conn.send(data.upper())
        except ConnectionResetError:
            break
    conn.close()


while True:
    conn,addr = server.accept()
    print(addr)
    t = Thread(target=communicate,args=(conn,))
    t.start()
客户端：
import socket


client = socket.socket()
client.connect(('127.0.0.1',8080))


while True:
    msg = input('>>>:').encode('utf-8')
    if len(msg) == 0:continue
    client.send(msg)
    data = client.recv(1024)
    print(data)
二、进程池线程池介绍
池：
    为了减缓计算机硬件的压力，避免计算机硬件设施崩溃
    虽然减轻了计算机的压力，但一定程度上降低了持续的效率

进程池线程池：
    为了限制开设的进程数和线程数，从而保证计算机硬件的安全

使用方法：
    concurrent.futures模块导入
    线程池创建（线程数=CPU核数*5左右）
    submit提交任务（提交任务的两种方式）
    异步提交的submit返回值对象
    shutdown关闭池并等待所有任务运行结束
    对象获取任务返回值
    进程池的使用，验证进程池在创建的时候里面固定有指定的进程数
    异步提交回调函数的使用

进程池：
from concurrent.futures import ProcessPoolExecutor
import time
import os


pool = ProcessPoolExecutor(5)        # 创建一个池子，池子里面有5个进程


def task(n):
    print(n,os.getpid())
    time.sleep(2)
    return n**2


def call_back(n):
    print('拿到了结果：%s'%n.result())


"""
提交任务的方式
    同步:提交任务之后，原地等待任务的返回结果，再继续执行下一步代码
    异步:提交任务之后，不等待任务的返回结果(通过回调函数拿到返回结果并处理)，直接执行下一步操作

"""

if __name__ == '__main__':
    for i in range(20):
        future = pool.submit(task,i).add_done_callback(call_back)
    print('主')
线程池：
from concurrent.futures import ThreadPoolExecutor
import time
import os


pool = ThreadPoolExecutor(5)        # 创建一个池子，池子里面有5个线程


def task(n):
    print(n,os.getpid())
    time.sleep(2)
    return n**2


def call_back(n):
    print('拿到了结果：%s'%n.result())


"""
提交任务的方式
    同步:提交任务之后，原地等待任务的返回结果，再继续执行下一步代码
    异步:提交任务之后，不等待任务的返回结果(通过回调函数拿到返回结果并处理)，直接执行下一步操作

"""

if __name__ == '__main__':
    for i in range(20):
        future = pool.submit(task,i).add_done_callback(call_back)
    print('主')
三、协程
进程：资源单位

线程：执行单位

协程：单线程下实现并发(能够在多个任务之间切换和保存状态来节省IO),
      这里注意区分操作系统的切换+保存状态是针对多个线程而言，
      而我们现在是想在单个线程下自己手动实现操作系统的切换+保存状态的功能

注意：协程这个概念完全是程序员自己想出来的东西，它对于操作系统来说根本不存在
      操作系统只知道进程和线程，并不是单个线程下实现切换+保存状态就能提升效率，
      如果没有遇到io操作反而会降低效率

高并发：
    多进程下开多线程，多线程下用协程

实现并发的手段：
    yield能够实现保存上次运行状态，但是无法识别遇到io才切

gevent模块：
    一个spawn就是一个帮你管理任务的对象
from gevent import monkey;monkey.patch_all()    # 检测所有的io行为
from gevent import spawn,joinall    # joinall列表里放多个对象，实现join效果
import time


def play(name):
    print('%s play 1' % name)
    time.sleep(5)
    print('%s play 2' % name)


def eat(name):
    print('%s eat 1' %name)
    time.sleep(3)
    print('%s eat 2' % name)


start = time.time()
g1 = spawn(play,'lucas')
g2 = spawn(eat,'lucas')
joinall([g1,g2])
print('主',time.time()-start)
四、协程实现服务端客户端通信
链接和通信都是io密集型操作，我们只需要在这两者之间来回切换其实就能实现并发的效果
服务端监测链接和通信任务，客户端起多线程同时链接服务端
服务端：
from gevent import monkey;monkey.patch_all()
from gevent import spawn
import socket


def communicate(conn):
    while True:
        while True:
            try:
                data = conn.recv(1024)
                if len(data) == 0:break
                print(data)
                conn.send(data.upper())
            except ConnectionResetError:
                break
        conn.close()


def sever():
    server = socket.socket()
    server.bind(('127.0.0.1',8080))
    server.listen(5)
    while True:
        conn,addr = server.accept()
        spawn(communicate,conn)


if __name__ == '__main__':
    s1 = spawn(sever)
    s1.join()
客户端：
from threading import Thread,current_thread
import socket


def client():
    client = socket.socket()
    client.connect(('127.0.0.1',8080))
    n = 1
    while True:
        data = '%s %s' % (current_thread().name,n)
        n += 1
        client.send(data.encode('utf-8'))
        info = client.recv(1024)
        print(info)


if __name__ == '__main__':
    for i in range(500):
        t = Thread(target=client)
        t.start()
五、IO模型
阻塞IO
非阻塞IO（服务端通信针对accept用s.setblocking(False)加异常捕获，cpu占用率过高）
IO多路复用
异步IO
扫码关注我们
微信号：SRE实战
拒绝背锅 运筹帷幄