进程池、线程池、回调函数、协程

from concurrent.futures import ProcessPoolExecutor  # 导入进程池模块
from concurrent.futures import ThreadPoolExecutor # 导入线程池模块
import os
import time
import random

# 下面以进程池为例，线程池只是使用导入模块不一样，仅此而已。
def task(name):
    print('name:[%s]|进程：[%s]正在运行' % (name, os.getpid()))
    time.sleep(random.randint(1, 3))   # 模拟进程运行耗费时间。

# 这一步的必要性：在创建进程时，会将代码以模块的方式从头到尾导入加载执行一遍
# （所以创建线程如果不写在main里面的话，这个py文件里面的所有代码都会从头到尾加载执行一遍
# 就会导致在创建进程的时候产生死循环。）
if __name__ == '__main__':
    pool = ProcessPoolExecutor(4)  # 设置线程池的大小，默认等于cpu的核心数。
    for i in range(10):
        pool.submit(task, '进程%s' % i)  # 异步提交（提交后不等待）
    
    pool.shutdown(wait=True)  # 关闭进程池入口不再提交，同时等待进程池全部运行完毕。（类似join方法）
    print('主') # 标识一下主进程的完毕之前的语句

from concurrent.futures import ProcessPoolExecutor  # 导入进程池模块
from concurrent.futures import ThreadPoolExecutor # 导入线程池模块
import os
import time
import random


def task(name):
    print('name:[%s]|进程[%s]正在运行...' % (name, os.getpid()))
    time.sleep(random.randint(1, 3))
    return '拿到[%s]|进程%s的结果...' % (name, os.getpid())

if __name__ == '__main__':
    pool = ProcessPoolExecutor(4)
    result = []  # 创建一个空列表来搜集执行结果
    for i in range(10):
        res = pool.submit(task, '进程%s' % i).result()  # 使用.result()方法得到每次的结果，同步调用
        result.append(res)
    pool.shutdown(wait=True)
    for j in result:
        print(j)
    print('主进程')

from concurrent.futures import ProcessPoolExecutor
import os
import random
import time

def task(name):
    time.sleep(random.randint(1, 3))
    print('name: %s 进程[%s]运行...' % (name, os.getpid()))


if __name__ == '__main__':
    pool = ProcessPoolExecutor(4)
    for i in range(10):
        pool.submit(task, '进程%s' % i)   # 异步调用，提交后不等待结果，继续执行代码

    pool.shutdown(wait=True)
    print('主进程')

from concurrent.futures import ThreadPoolExecutor
import time
import random
import requests


def task(url):
    print('获取网站[%s]信息' % url)
    response = requests.get(url)  # 下载页面
    time.sleep(random.randint(1, 3))
    return {'url': url, 'content': response.text}  # 返回结果：页面地址和页面内容

futures = []
def back(res):
    res = res.result()  # 取到提交任务的结果（回调函数固定写法）
    res = '网站[%s]内容长度：%s' % (res.get('url'), len(res.get('content')))
    futures.append(res)
    return futures

if __name__ == '__main__':
    urls = [
        'Http://www.baidu.com',
        'http://www.dgtle.com/',
        'https://www.bilibili.com/'
    ]
    pool = ThreadPoolExecutor(4)
    futures = []
    for i in urls:
        pool.submit(task, i).add_done_callback(back)  # 执行完线程后，使用回调函数

    pool.shutdown(wait=True)
    for j in futures:
        print(j)

from gevent import monkey; monkey.patch_all()  # 监测代码中所有IO行为
# gevent模块不能识别它本身以外的所有的IO行为,但是它内部封装了一个模块，能够帮助我们识别所有的IO行为

from gevent import spawn  # 从gevent模块导入spawn，来使用‘切’的方法
import time
import random

def heng(name):
    print('%s 哼了一下...' % name)
    time.sleep(random.randint(1, 3))
    print('%s 哼完了' % name)


def ha(name):
    print('%s 哈了一下' % name)
    time.sleep(random.randint(1, 3))
    print('%s 哈完了' % name)


start = time.time()  # 标记开始时间
s1 = spawn(heng, '王大锤')    # 标记并运行heng函数（遇到IO，切）
s2 = spawn(ha, '至尊宝')      # 标记并运行ha函数（遇到IO，切）

s1.join()
s2.join()   # s1、s2都执行完毕后才继续执行
print('运行时间：', time.time()-start)

# 服务端：
from gevent import monkey;monkey.patch_all()
from gevent import spawn
import socket
n = 0

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


def server(): # 切点
    global n
    server = socket.socket()
    server.bind(('127.0.0.1',8080))
    server.listen(5)
    while True:
        conn, addr = server.accept()
        # n += 1
        spawn(communicate, conn)    # 切点
        # print(n)

if __name__ == '__main__':
    s1 = spawn(server)
    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()