Python Day38 :线程回调/线程中队列/事件event/yield实现并发/协程之greenlet/协程之gevent模块

## 线程回调

```python
1,创建一个线程对象,线程对象的执行任务函数:task,task的参数是回调函数call_back,回调函数的参数是task的执行结果.
def call_back(res):
    print("任务结果拿到了:%s" % res)
def task(callback):
    # global res
    print("run")
    time.sleep(1)
    #     # return 100
    res = 100 # 表示任务结果
    callback(res) # 执行回调函数 并传入任务结果
 
t = Thread(target=task,args=(parser,))
t.start()
print("over")

```

## 线程中的队列

```python
线程中的队列有三种:
  第一种:q=Queue()
        q.put()
        q.get()
        跟进程中的Joinablequeue使用方法一模一样,但是不具备IPC
  第二种:q=LifoQueue()
        q.put()
        q.get()
        后进先出,先进后出,模拟堆栈的存储方式
  第三种:q=PriorityQueue()
        q.put()
        q.get()
          具备优先级的队列,存储对象需要可以比较大小,比较越小的优先级越高,自定义对象不能使用比较运算符,故不能存储,但是可以覆盖运算符加载,如下:
 class A(object):
    def __init__(self,age):
        self.age = age
    # def __lt__(self, other):
    #     return self.age < other.age
    # def __gt__(self, other):
    #     return self.age > other.age
    def __eq__(self, other):
        return self.age == other.age
a1 = A(50)
a2 = A(50)       
print(a1 == a2)        
        
```

## 事件

```python
boot_event = Event()
# boot_event.clear() 回复事件的状态为False
# boot_event.is_set() 返回事件的状态
# boot_event.wait()等待事件发生 ,就是等待事件被设置为True
# boot_event.set() 设置事件为True
def boot_server():
    print("正在启动服务器......")
    time.sleep(3)
    print("服务器启动成功!")
    boot_event.set() # 标记事件已经发生了

def connect_server():
    boot_event.wait() # 等待事件发生,不需要设置if判断真假,此处是阻塞方法.
    print("链接服务器成功!")

t1 = Thread(target=boot_server)
t1.start()
t2 = Thread(target=connect_server)
t2.start()

```

## yield实现单线程并发

```python
# 使用生成器来实现 单线 并发多个任务
import time
def func1():
    a = 1
    for i in range(10000000):
        a += 1
        print("a run")
        time.sleep(10)
        yield
def func2():
    res = func1()
    a = 1
    for i in range(10000000):
        a += 1
        print("b run")
        next(res)#通过next方法取yield值.

st = time.time()
func2()
print(time.time() - st)

```

## greenlet模块

```python
创建greenlet对象,参数是执行任务函数,通过"greenlet对象".switch(),跳到该对象的执行任务函数中.如果有多个switch(),将记录上次位置,从上次结束位置开始往下执行.
import greenlet
import time
def task1():
    print("task1 run")
    g2.switch()
    print("task1 over")
    g2.switch()

def task2():
    print("task2 run")
    g1.switch()
    time.sleep(2)
    print("task2 over")

g1 = greenlet.greenlet(task1)
g2 = greenlet.greenlet(task2)

g1.switch()
# g2.switch()
print("主 over")

```

## gevent模块

```python
# gevent 不具备检测IO的能力  需要为它打补丁  打上补丁之后就能检测IO
# 注意补丁一定打在最上面    必须保证导入模块前就打好补丁
from gevent import monkey
monkey.patch_all()   #打补丁后,并不是所有IO都能识别,要看具体补丁内封装了哪些IO.

from threading import current_thread
import gevent,time

def task1():
    print(current_thread(),1)
    print("task1 run")
    # gevent.sleep(3)
    time.sleep(3)
    print("task1 over")

def task2():
    print(current_thread(),2)
    print("task2 run")
    print("task2 over")

# spawn 用于创建一个协程任务
g1 = gevent.spawn(task1)
g2 = gevent.spawn(task2)

# 任务要执行,必须保证主线程没挂  因为所有协程任务都是主线在执行   ,必须调用join来等待协程任务
# g1.join()
# g2.join()
# 理论上等待执行时间最长的任务就行 , 但是不清楚谁的时间长 可以全部join

gevent.joinall([g1,g2])
print("over")

打补丁的实现原理:就是覆盖IO方法,由阻塞改成非阻塞.




```