import time

def jishi1hao():

    for  i in range(6):

        print("快快来~~~~")

        yield #yield 可以记录任务的执行状态

        time.sleep(1)

        print("%s号客户2s搞定"%i)

def jishi2hao():

    g=jishi1hao() #获取到生成器

    g.__next__() #执行第一段函数，到第一个yield结束

    for  i in range(5):

        time.sleep(1)

        print("%s号技师正在忙！！！"%i)

        g.__next__() #继续到下一个yield

jishi2hao()

#使用yield可以实现程序的切换执行，但是不能提高效率，只是简单的程序分段穿插运行

#基于yield并发执行，多任务之间来回切换，这就是个简单的协程的体现，但是他能够节省I/O时间吗？不能

import time

def consumer():

    '''任务1:接收数据,处理数据'''

    while True:

        x=yield

        time.sleep(1) #发现什么？只是进行了切换，但是并没有节省I/O时间

        print('处理了数据：',x)

def producer():

    '''任务2:生产数据'''

    g=consumer()

    next(g)  #找到了consumer函数的yield位置

    for i in range(3):

        g.send(i)  #给yield传值，然后再循环给下一个yield传值，并且多了切换的程序，比直接串行执行还多了一些步骤，导致执行效率反而更低了。

        print('发送了数据：',i)

start=time.time()

#基于yield保存状态,实现两个任务直接来回切换,即并发的效果

#PS:如果每个任务中都加上打印,那么明显地看到两个任务的打印是你一次我一次,即并发执行的.

producer() #我在当前线程中只执行了这个函数，但是通过这个函数里面的send切换了另外一个任务

stop=time.time()

# 串行执行的方式

s_t=time.time()

res=producer()

consumer()

e_t=time.time()

print("yield的时间>>>",stop-start)

print("串行的时间>>>",e_t-s_t)

#结果显示

#yield的时间>>> 3.0015313625335693

#串行的时间>>> 3.0011236667633057

  #真正的协程模块就是使用greenlet完成的切换

from greenlet import greenlet

def eat(name):

    print('%s eat 1' %name)  #

    g2.switch('taibai')   #

    print('%s eat 2' %name) #

    g2.switch() #

def play(name):

    print('%s play 1' %name) #

    g1.switch()      #

    print('%s play 2' %name) #

g1=greenlet(eat)

g2=greenlet(play)

g1.switch('taibai')#可以在第一次switch时传入参数，以后都不需要  1

import gevent

import time

def func1(i):

    print("func1开始")

    gevent.sleep(2)

    print("1111>>>",i)

def func2(i):

    print("func2开始")

    gevent.sleep(2)

    print("2222>>>", i)

if __name__ == '__main__':

    s_t=time.time()

    g1=gevent.spawn(func1,"a")

    g2=gevent.spawn(func2,"b")

    g1.join()

    g2.join()

    e_t=time.time()

    print("gevent耗时>>>",e_t-s_t)

    print("主任务结束")

from gevent import monkey;monkey.patch_all() #必须写在最上面，这句话后面的所有阻塞全部能够识别了

import gevent  #直接导入即可

import time

def eat():

    #print()　　

    print('eat food 1')

    time.sleep(2)  #加上mokey就能够识别到time模块的sleep了

    print('eat food 2')

def play():

    print('play 1')

    time.sleep(1)  #来回切换，直到一个I/O的时间结束，这里都是我们个gevent做得，不再是控制不了的操作系统了。

    print('play 2')

g1=gevent.spawn(eat)

g2=gevent.spawn(play_phone)

gevent.joinall([g1,g2])

print('主')

from gevent import spawn,joinall,monkey;monkey.patch_all()

import time

def task(pid):

    """

    Some non-deterministic task

    """

    time.sleep(0.5)

    print('Task %s done' % pid)

def synchronous():#同步提交任务,串行,一次出来一个

    for i in range(10):

        task(i)

def asynchronous():#异步提交任务

    g_l=[spawn(task,i) for i in range(10)]

    joinall(g_l)

if __name__ == '__main__':

    print('Synchronous:')

    synchronous()

    print('Asynchronous:')

    asynchronous()

#1、输入操作：read、readv、recv、recvfrom、recvmsg共5个函数，如果会阻塞状态，则会经历wait data和copy data两个阶段，如果设置为非阻塞则在wait 不到data时抛出异常

#2、输出操作：write、writev、send、sendto、sendmsg共5个函数，在发送缓冲区满了会阻塞在原地，如果设置为非阻塞，则会抛出异常

#3、接收外来链接：accept，与输入操作类似

#4、发起外出链接：connect，与输出操作类似

# 服务端

import socket

import time

server=socket.socket()

server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

server.bind(('127.0.0.1',8083))

server.listen(5)

server.setblocking(False) #设置不阻塞

r_list=[]  #用来存储所有来请求server端的conn连接

w_list={}  #用来存储所有已经有了请求数据的conn的请求数据

while 1:

    try:

        conn,addr=server.accept() #不阻塞，会报错

        r_list.append(conn)  #为了将连接保存起来，不然下次循环的时候，上一次的连接就没有了

    except BlockingIOError:

        # 强调强调强调：！！！非阻塞IO的精髓在于完全没有阻塞！！！

        # time.sleep(0.5) # 打开该行注释纯属为了方便查看效果

        print('在做其他的事情')

        print('rlist: ',len(r_list))

        print('wlist: ',len(w_list))

        # 遍历读列表，依次取出套接字读取内容

        del_rlist=[] #用来存储删除的conn连接

        for conn in r_list:

            try:

                data=conn.recv(1024) #不阻塞，会报错

                if not data: #当一个客户端暴力关闭的时候，会一直接收b''，别忘了判断一下数据

                    conn.close()

                    del_rlist.append(conn)

                    continue

                w_list[conn]=data.upper()

            except BlockingIOError: # 没有收成功，则继续检索下一个套接字的接收

                continue

            except ConnectionResetError: # 当前套接字出异常，则关闭，然后加入删除列表，等待被清除

                conn.close()

                del_rlist.append(conn)

        # 遍历写列表，依次取出套接字发送内容

        del_wlist=[]

        for conn,data in w_list.items():

            try:

                conn.send(data)

                del_wlist.append(conn)

            except BlockingIOError:

                continue

        # 清理无用的套接字,无需再监听它们的IO操作

        for conn in del_rlist:

            r_list.remove(conn)

        #del_rlist.clear() #清空列表中保存的已经删除的内容

        for conn in del_wlist:

            w_list.pop(conn)

        #del_wlist.clear()

#客户端

import socket

import os

import time

import threading

client=socket.socket()

client.connect(('127.0.0.1',8083))

while 1:

    res=('%s hello' %os.getpid()).encode('utf-8')

    client.send(res)

    data=client.recv(1024)

    print(data.decode('utf-8'))

##多线程的客户端请求版本

# def func():

#     sk = socket.socket()

#     sk.connect(('127.0.0.1',9000))

#     sk.send(b'hello')

#     time.sleep(1)

#     print(sk.recv(1024))

#     sk.close()

#

# for i in range(20):

#     threading.Thread(target=func).start()

#服务端

from socket import *

import select

server = socket(AF_INET, SOCK_STREAM)

server.bind(('127.0.0.1',8093))

server.listen(5)

# 设置为非阻塞

server.setblocking(False)

# 初始化将服务端socket对象加入监听列表，后面还要动态添加一些conn连接对象，当accept的时候sk就有感应，当recv的时候conn就有动静

rlist=[server,]

rdata = {}  #存放客户端发送过来的消息

wlist=[]  #等待写对象

wdata={}  #存放要返回给客户端的消息

print('预备！监听！！！')

count = 0 #写着计数用的，为了看实验效果用的，没用

while True:

    # 开始 select 监听,对rlist中的服务端server进行监听，select函数阻塞进程，直到rlist中的套接字被触发（在此例中，套接字接收到客户端发来的握手信号，从而变得可读，满足select函数的“可读”条件），被触发的（有动静的）套接字（服务器套接字）返回给了rl这个返回值里面；

    rl,wl,xl=select.select(rlist,wlist,[],0.5)

    print('%s 次数>>'%(count),wl)

    count = count + 1

    # 对rl进行循环判断是否有客户端连接进来,当有客户端连接进来时select将触发

    for sock in rl:

        # 判断当前触发的是不是socket对象, 当触发的对象是socket对象时,说明有新客户端accept连接进来了

        if sock == server:

            # 接收客户端的连接, 获取客户端对象和客户端地址信息

            conn,addr=sock.accept()

            #把新的客户端连接加入到监听列表中，当客户端的连接有接收消息的时候，select将被触发，会知道这个连接有动静，有消息，那么返回给rl这个返回值列表里面。

            rlist.append(conn)

        else:

            # 由于客户端连接进来时socket接收客户端连接请求，将客户端连接加入到了监听列表中(rlist)，客户端发送消息的时候这个连接将触发

            # 所以判断是否是客户端连接对象触发

            try:

                data=sock.recv(1024)

                #没有数据的时候，我们将这个连接关闭掉，并从监听列表中移除

                if not data:

                    sock.close()

                    rlist.remove(sock)

                    continue

                print("received {0} from client {1}".format(data.decode(), sock))

                #将接受到的客户端的消息保存下来

                rdata[sock] = data.decode()

                #将客户端连接对象和这个对象接收到的消息加工成返回消息，并添加到wdata这个字典里面

                wdata[sock]=data.upper()

                #需要给这个客户端回复消息的时候，我们将这个连接添加到wlist写监听列表中

                wlist.append(sock)

            #如果这个连接出错了，客户端暴力断开了（注意，我还没有接收他的消息，或者接收他的消息的过程中出错了）

            except Exception:

                #关闭这个连接

                sock.close()

                #在监听列表中将他移除，因为不管什么原因，它毕竟是断开了，没必要再监听它了

                rlist.remove(sock)

    # 如果现在没有客户端请求连接,也没有客户端发送消息时，开始对发送消息列表进行处理，是否需要发送消息

    for sock in wl:

        sock.send(wdata[sock])

        wlist.remove(sock)

        wdata.pop(sock)

    # #将一次select监听列表中有接收数据的conn对象所接收到的消息打印一下

    # for k,v in rdata.items():

    #     print(k,'发来的消息是：',v)

    # #清空接收到的消息

    # rdata.clear()

---------------------------------------

#客户端

from socket import *

client=socket(AF_INET,SOCK_STREAM)

client.connect(('127.0.0.1',8093))

while True:

    msg=input('>>: ').strip()

    if not msg:continue

    client.send(msg.encode('utf-8'))

    data=client.recv(1024)

    print(data.decode('utf-8'))

client.close()