线程与进程（续）

# 服务端
import socket
from threading import Thread
service = socket.socket()
service.bind((‘127.0.0.1‘,8080))
service.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 = service.accept()
    print(addr)
    print(conn)
    t = Thread(target=communicate,args=(conn,))
    t.start()

#客户端
import socket
client = socket.socket()
client.connect((‘127.0.0.1‘,8080))

while True:
    info  = input(‘>>>:‘).encode(‘utf-8‘)
    if len(info) == 0:continue
    client.send(info)
    data = client.recv(1024)
    print(data)

异步提交：

异步调用：提交完一个任务之后，不在原地等待，结果，而是直接执行下一个行代码，会导致任务是并发执行的

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time
import os
def task(name):
    print(‘%s %s is running‘% (name,os.getpid()))
    time.sleep(1)


if __name__ == ‘__main__‘:
    p = ProcessPoolExecutor(4)　　#默认情况下不指定使用时cpu的核心数
    for i in range(20):
        p.submit(task,‘进程%s的pid:‘%i)
    print(‘主‘)

输出结果：
进程12的pid: 11484 is running
进程13的pid: 11072 is running
进程14的pid: 2784 is running
进程15的pid: 12328 is running

进程16的pid: 11484 is running
进程17的pid: 11072 is running
进程18的pid: 2784 is running
进程19的pid: 12328 is running
根据结果可以看出一直是4个进程在进行运算，限制了进程数

同步提交
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time
import os
def task(name):
    print(‘%s %s is running‘% (name,os.getpid()))
    time.sleep(1)
    return 123  # 返回结果
if __name__ == ‘__main__‘:
    p = ProcessPoolExecutor(4)　　#默认不指定参数，值是cpu核心数的5倍
    for i in range(20):
        res = p.submit(task,‘进程%s的pid:‘%i).result()   #提交完任务原地等待结果
        print(res)
    print(‘主‘)
输出:
进程0的pid: 13900 is running
123
进程1的pid: 8996 is running
123
进程2的pid: 13496 is running
123
进程3的pid: 7548 is running
123
进程4的pid: 13900 is running
123
进程5的pid: 8996 is running
123
进程6的pid: 13496 is running
123

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time
import os
def task(name,n):
    print(‘%s %s is running‘% (name,os.getpid()))
    time.sleep(1)
    return n**2
if __name__ == ‘__main__‘:
    p = ThreadPoolExecutor(4)
    # 提交任务的两种方式
    # 同步调用：提交完成一个任务后，就在原地等待，等待任务完完整整地运行完毕拿到结果后，再执行下一行代码，会导致任务是串行执行的。
    # 异步调用：提交完一个任务之后，不在原地等待，结果，而是直接执行下一个行代码，会导致任务是并发执行的
    l=[]
    for i in range(10):
        future = p.submit(task,‘进程pid:‘,i)
        l.append(future)
    p.shutdown(wait=True)   #关闭进程池的入口，原地等待进程池内所有任务运行完毕
    for future in l:
        print(future.result())

    print(‘主‘)
输出结果：

进程pid: 12932 is running
进程pid: 12932 is running
进程pid: 12932 is running
进程pid: 12932 is running
进程pid: 12932 is running
进程pid: 12932 is running
进程pid: 12932 is running
进程pid: 12932 is running
进程pid: 12932 is running
进程pid: 12932 is running
0
1
4
9
16
25
36
49
64
81
主

# 回调函数，异步提交之后一旦任务有返回结果，自动交给另外一个任务执行
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import time
import os
pool = ProcessPoolExecutor(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__‘:
    t_list=[]
    for i in range(10):
        future = pool.submit(task,i).add_done_callback(call_back)
        t_list.append(future)
    print(‘主‘)
输出：

主
0 11468
1 12216
2 10784
3 5564
4 13252
5 11468
我拿到了结果：0
6 12216
我拿到了结果：1
7 10784
我拿到了结果：4
8 5564
我拿到了结果：9
9 13252

from gevent import monkey;monkey.patch_all()   # 添加该模块会自动识别所有代码中的io操作
from gevent import spawn

# gevent本身不能识别time.sleep不属于该模块的io操作
import time
def heng(name):
    print(‘%s 哼‘%name)
    time.sleep(2)
    print(‘%s 哼‘% name)
def ha(name):
    print(‘%s 哈‘%name)
    time.sleep(3)
    print(‘%s 哈‘% name)
start = time.time()

# heng(‘egon‘)
# ha(‘yzn‘)
# print(‘主‘,time.time()-start)    # 5.001242399215698

s1=spawn(heng,‘egon‘)
s2=spawn(ha,‘echo‘)
s1.join()
s2.join()
print(‘主‘,time.time()-start)    # 3.0121893882751465