python3 异步IO\数据库\队列\缓存

yield 详解

转至 https://www.cnblogs.com/maoxiaolv/p/6425875.html

协程

协程：又称微线程，纤程，协程是一种用户态的轻量级线程

 

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

 

 

 

select 多并发socket 例子

服务端：

import select
import socket
import sys
import queue
 
server = socket.socket()
server.setblocking(False)
server_addr = ('localhost',9999)
print('starting up on %s port %s' % server_addr)
server.bind(server_addr)
server.listen(5)
 
inputs = [server,]
outputs = []
message_queues = {}
 
while True:
    print('waiting for next event...')
    readable,writeable,exeptional = select.select(inputs, outputs, inputs)
    
    for s in readable:      #每个s就是一个socket
        if s is server:
            conn,client_addr = s.accept()
            print('new connection from',client_addr)
            conn.setblocking(False)
            inputs.append(conn)
            message_queues[conn] = queue.Queue()
        else:
            data = s.recv(1024)
            if data:
                print("收到来自[%s]的数据：" %s.getpeername()[0],data)
                message_queues[s].put(data)
                if s not in outputs:
                    outputs.append(s)
            else:
                print('客户端断开了',s)
                if s in outputs:
                    outputs.remove(s)
                 
                inputs.remove(s)
                del message_queues[s]         
                               
    for s in writeable:
        try:
            next_msg = message_queues[s].get_nowait()
        except queue.Empty:
            print("client [%s]" %s.getpeername()[0],'queue is empty..')
            outputs.remove(s)
        else:
            print('sending msg to [%s]' %s.getpeername()[0],next_msg)
            s.send(next_msg.upper())    
            
    for s in exeptional:
        print('handling exception for ',s.getpeername)
        inputs.remove(s)
        if s in outputs:
            outputs.remove(s)
        s.close()
        del message_queues[s]        

客户端： 在range中调整并发客户端数目 当个数为1000时 出现select数目过多问题

import socket
import sys
 
messages = [b'This is the message.',
            b'It will be sent',
            b'in parts.']
 
server_address = ('localhost',9999)
 
socks = [socket.socket(socket.AF_INET,socket.SOCK_STREAM) for i in range(100)]
 
print('connecting to %s port %s' %server_address)
 
for s in socks:
    s.connect(server_address)
 
for message in messages:
    for s in socks:
        print('%s:sending "%s"' %(s.getsockname(),message))
        s.send(message)
     
    for s in socks:
        data = s.recv(1024)
        print('%s:recvived "%s"' %(s.getsockname(),data))
        if not data:
            print(sys.stderr,'closing socket',s.getsockname)

 

linux中改socket代开文件句柄数限制

 

查看：ulimit -n

修改：ulimit -SHn 65535     假如限制数改为65535

 selectors模块服务端

import selectors
import socket

sel = selectors.DefaultSelector()

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):
    data = conn.recv(1024)
    if data:
        print('echoing',repr(data),'to',conn)
        conn.send(data.upper())
    else:
        print('closing',conn)
        sel.unregister(conn)
        conn.close()

sock = socket.socket()
sock.bind(('localhost',9999))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)

while True:
    events = sel.select()
    for key,mask in events:
        callback = key.data
        callback(key.fileobj,mask)

selectors模块服务端 封装类版本

import selectors
import socket

class accept_class(object):
    def __init__(self):
        self.conn = None
        self.addr = None
        self.mask = None

    def accept(self,sock, mask):
        conn, addr = sock.accept()
        self.conn = conn
        self.addr = addr
        self.mask = mask
        print('accepted', self.conn, 'from', self.addr)
        self.conn.setblocking(False)
        read1 = read_class()
        sel.register(self.conn, selectors.EVENT_READ, read1.read)
        
class read_class(object):
    def __init__(self):
        self.conn = None
        self.mask = None
    
    def read(self,conn,mask):
        data = conn.recv(1000)  # Should be ready
        print(data)
        if data:
            print('echoing', repr(data), 'to', conn)
            conn.send(data)  # Hope it won't block
        else:
            print('closing', conn)
            sel.unregister(conn)
            conn.close()

            
sock = socket.socket()
sock.bind(('localhost', 9999))
sock.listen(100)
sock.setblocking(False)
sel = selectors.DefaultSelector()
accept1 = accept_class()
sel.register(sock, selectors.EVENT_READ, accept1.accept)
    
while True:
    events = sel.select()
    for key, mask in events:
        callback = key.data
        callback(key.fileobj, mask)

六、有兴趣接电子设计相关小型项目的请加下群，每个项目一般在1000元以内，非诚勿扰