#用线程池+协程的一小段程序
import asyncio
from multiprocessing.dummy import Pool
@asyncio.coroutine
def write():
with open('aa.txt','a') as f:
f.write('hello,wold\n')
@asyncio.coroutine
def hello(a,b):
yield from asyncio.sleep(5)
yield from write()#协程调用方法(函数),该方法必须是异步方法,可以有返回值
print(a,b)
return 1
def works(_):
print(_)
#loop=_[1]
#can=_[0]
try:
can=_
loop=asyncio.new_event_loop()
asyncio.set_event_loop(loop)
#loop=asyncio.get_event_loop()#不能使用这个,事件循环是系统生成的,因为是多线程,所以要自己创建、设置
if loop.run_until_complete(hello('hello',can))==1:
print('get',can)
else:
print('no get',can)
loop.close()
return 1
except Exception as e:
print(e)
if __name__=="__main__":
try:
pool=Pool(3)
l=list(range(10))
print(l,'\n')
p=pool.map_async(works,l).get()#取值是为了让主线程在这里等待
print(p)
except Exception as e:
print(e)
#finally:
#pool.close()
#pool.join()
进程池的一些运用:
#/usr/bin/python3
import multiprocessing
import time,os,sys
def F(a):
print('in F')
pool1=multiprocessing.Pool(5)
l=list(range(20))
result=pool1.map_async(AA,l)
pool1.close()
pool1.join()
print('AA',result.get())
time.sleep(5)
print('this is F,value is ',a)
return 1
def G(a):
print('in G')
time.sleep(10)
print('this is G,value is ',a)
return 2
def H(a):
print('in H')
time.sleep(20)
print('this is H,value is ',a)
return 3
def I(a):
print('in I')
time.sleep(15)
print('this is I,value is ',a)
return 4
def J(a):
print('in J')
time.sleep(30)
print('this is J,value is ',a)
return 5
def K(a):
print('in K')
time.sleep(25)
print('this is K,value is ',a)
return 6
def AA(a):
print("in AA...")
time.sleep(1)
print('this is AA',a)
return a
pool=multiprocessing.Pool(3)
if __name__=='__main__':
print('in..')
try:
l=list(range(20))
result=pool.map_async(AA,l).get()
print(result)
except Exception as e:
print(e)
finally:
pool.close()
pool.join()
'''
if __name__=='__main__':
print('in..')
try:
fun_lt=[F,G,H,I,J,K]
result_lt=[]
print(sys.argv)
for f in fun_lt:
result_lt.append(pool.apply_async(f,(sys.argv,)))
#for r in result_lt:##没有关闭时打印每次返回的结果
#print(r.get())
except Exception as e:
print(e)
finally:
pool.close()
pool.join()
for r in result_lt:#统一打印
print(r.get())
'''
网络通信方面的(epoll +socket):
#直接运行可能会出问题,因为在编写的时候删除了与数据库相关的代码
#conding='utf-8'
import psycopg2
import config
import select,socket,traceback
import sys,os,time,datetime,argparse
import base64,json,types,string,errno
from multiprocessing import pool
from multiprocessing.dummy import Pool as ThreadPool
from decimal import Decimal
#客户端连接
def newconnect_client(fileno):
try:
conn,address=serversocket.accept()
conn.setblocking(False)
epoll.register(conn.fileno(),select.EPOLLIN)
d_connect[conn.fileno()]=conn
d_request[conn.fileno()]=''
d_response[conn.fileno()]=''
except:
traceback.print_exc()
#接收客户端数据
def request_client_data(fileno):
try:
data=""
while True:
tmpdata=d_connect[fileno].recv(1024).decode()#将byte转化str
if len(tmpdata)==0:
break;
data=data+tmpdata
except:
#if socket.error[0]==11:
pass
#if socket.error.errno==errno.EAGAIN:
#pass
#print(socket.error.errno)
#print(errno.EAGAIN)
#else:
#print(e)
d_request[fileno]=d_request[fileno]+data
jquery=json.loads(d_request[fileno])
if isinstance(jquery,dict):
result=greenplumAPI([jquery,fileno])
d_response[fileno]=result
elif isinstance(jquery,list):
jquery=[[j,fileno] for j in jquery]
result=pool.map_async(greenplumAPI,jquery).get()
d_response[fileno]={'result':result}
epoll.modify(fileno,select.EPOLLOUT)
#返回客户端数据
def responce_client_data(fileno):
try:
#d_connect[fileno].sendall(bytearray(json.dumps(d_response[fileno]),encoding='utf-8'))
len_t=len(bytearray(json.dumps(d_response[fileno]),encoding='utf-8'))
len_c=0
while True:
len_c+=d_connect[fileno].send(bytearray(json.dumps(d_response[fileno]),encoding='utf-8')[len_c:])
if len_c == len_t:
break
close_client(fileno)
return 0
except:
traceback.print_exc()
close_client(fileno)
return -1
#关闭客户端及epoll
def close_client(fileno):
try:
epoll.unregister(fileno)
d_connect[fileno].close()
if fileno in d_connect.keys():
del d_connect[fileno]
if fileno in d_request.keys():
del d_request[fileno]
if fileno in d_response.keys():
del d_response[fileno]
except:
traceback.print_exc()
serversocket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
serversocket.bind((config.Gpapi_host,int(config.Gpapi_port)))
serversocket.listen(1)
serversocket.setblocking(0)
epoll=select.epoll()
epoll.register(serversocket.fileno(),select.EPOLLIN)
pool=ThreadPool(40)
d_connect={}#客户端连接数据
d_request={}#客户端发送信息
d_response={}#返回客户端信息
try:
while True:
events=epoll.poll(1)#epoll轮询
for fileno,event in events:
if fileno==serversocket.fileno():#初始化
newconnect_client(fileno)
elif event&select.EPOLLIN:#接收数据
request_client_data(fileno)
elif event&select.EPOLLOUT:#回传数据
responce_client_data(fileno)
elif event&select.EPOLLHUP:#退出
close_client(fileno)
except:
traceback.print_exc()
finally:
epoll.unregister(serversocket.fileno())
epoll.close()
pool.close()
pool.join()
serversocket.close()
知识点:
1.用with XXX as X,模式:
class Content:
def __enter__(self):#进入时调用,必须有返回
print('enter')
return self
def __exit__(self,type,value,trace):#结束时调用,参数个数一定是这几个
print('exit')
def printa(self):
print('a')
with Content() as c:
c.printa()
2.普通方法、类方法、静态方法:
普通方法 可以访问类里面的属性 可以继承 只能实例可以调用;def func(self,data)
类方法 可以访问类里面的属性 可以继承 实例和类都能调用;def func(cls,data)
静态方法 不能访问类里面的属性 不能继承 实例和类都能调用。def func(data)