一、定時器

Timer的父類是Thread，所以定時器這里用的是執行緒

# 多長時間之后執行一個任務
from threading import Timer


def task(name):
    print('我是大帥比--%s'%name)


if __name__ == '__main__':
    # t = Timer(2, task,args=('lqz',))  # 本質是開了個執行緒，延遲一秒執行  Timer(秒數，函式，arges=一個元組)
    t = Timer(2, task,kwargs={'name':'lqz'})  # 本質是開了個執行緒，延遲一秒執行
    t.start()

二、協程

協程是為了實作單執行緒下的并發，屬性執行緒下
協程要解決的問題：保存狀態+切換
yield：生成器，只要函式中有yield關鍵字，這個函式就是生成器，通過yield可以實作保存狀態+切換

import time

# 串行執行
def func1():
    for i in range(100000000):
        i += 1


def func2():
    for i in range(100000000):
        i += 1


if __name__ == '__main__':
    ctime = time.time()
    func1()
    func2()
    print(time.time() - ctime)  # 7.03256796435


# 通過yield，實作保存狀態加切換（自定義的切換，并不是遇到io才切，所有它并不能節約時間）
# 單純的切換，不但不會提高效率，反而會講低效率
def func1():
    for i in range(100000000):
        i += 1
        yield


def func2():
    g=func1() # 先執行一下func1
    for i in range(100000000):
        i += 1
        next(g) # 回到func1執行


if __name__ == '__main__':
    ctime = time.time()
    func2()
    print(time.time() - ctime) #14.764776706695557



# 協程并不是真是存在的某個東西，而是程式員臆想出來的
# 程式員控制，不讓自己的程式遇到io，看上去，就實作并發了

'''
優點如下：
協程的切換開銷更小，屬于程式級別的切換，作業系統完全感知不到，因而更加輕量級
單執行緒內就可以實作并發的效果，最大限度地利用cpu

缺點如下：
協程的本質是單執行緒下，無法利用多核，可以是一個程式開啟多個行程，每個行程內開啟多個執行緒，每個執行緒內開啟協程
協程指的是單個執行緒，因而一旦協程出現阻塞，將會阻塞整個執行緒

總結協程特點：
必須在只有一個單執行緒里實作并發
修改共享資料不需加鎖
用戶程式里自己保存多個控制流的背景關系堆疊(需要保存狀態)
附加：一個協程遇到IO操作自動切換到其它協程（如何實作檢測IO，yield、greenlet都無法實作，就用到了gevent模塊（select機制））
'''

三、greenlet模塊

協程相關模塊

from greenlet import greenlet
import time
# 遇到io不會切，初級模塊，gevent模塊基于它寫的，處理io切換
def eat():
    print('我吃了一口')
    time.sleep(1)
    # p.switch()
    print('我又吃了一口')
    # p.switch()


def play():
    print('我玩了一會')
    e.switch()
    print('我又玩了一會')


if __name__ == '__main__':
    e = greenlet(eat)
    p = greenlet(play)
    e.switch()

四、gevent模塊

協程相關模塊

# gevent基于greenlet寫的，實作了遇見io自動切換
import gevent
import time

def eat(name):
    print('%s 吃了一口' % name)
    gevent.sleep(1)  # io操作
    print('%s 又吃了一口' % name)


def play(name):
    print('%s 玩了一會' % name)
    gevent.sleep(2)
    print('%s 又玩了一會' % name)


if __name__ == '__main__':
    ctim = time.time()
    e = gevent.spawn(eat,'lqz')
    p = gevent.spawn(play,'lqz')
    e.join() # 等待e執行完成
    p.join()
    print('主')
    print(time.time() - ctim)  #2.0165154933929443

    這個程式執行完成，最少需要多長時間 2s多一點
    ctim=time.time()
    eat('lqz')
    play('lqz')
    print(time.time()-ctim) # 3.0190377235412598

gevent模塊加上猴子補丁

from gevent import monkey;monkey.patch_all()#這句話必須寫
import gevent
import time

def eat(name):
    print('%s 吃了一口' % name)
    time.sleep(1)  # io操作，被猴子補丁替換之后，gevent.sleep()
    print('%s 又吃了一口' % name)


def play(name):
    print('%s 玩了一會' % name)
    time.sleep(2)
    print('%s 又玩了一會' % name)


if __name__ == '__main__':
    ctim = time.time()
    e = gevent.spawn(eat,'lqz')
    p = gevent.spawn(play,'lqz')
    e.join() # 等待e執行完成
    p.join()
    print('主')
    print(time.time() - ctim)  #2.0165154933929443

五、單執行緒的套接字并發

使用gevent實作單執行緒下的套接字并發效果

六、asyncio模塊

3.4及其之前版本使用的asyncio模塊

import time
import asyncio

# 把普通函式變成協程函式
# 3.4及其以前這么寫，3.5開始就棄用了，3.5版本及其之后用了不報錯但會提示已經啟用
@asyncio.coroutine
def task():
    print('開始了')
    yield from asyncio.sleep(1)  #asyncio.sleep(1)模擬io
    print('結束了')


loop=asyncio.get_event_loop()  # 獲取一個時間回圈物件#

# 協程函式加括號，并不會真正的去執行，它需要提交給loop，讓loop回圈著去執行
# 協程函式串列

ctime=time.time()
t=[task(),task()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time()-ctime)

現在使用的asyncio模塊用法

import time
import asyncio
from threading import current_thread
# 表示我是協程函式,等同于3.5之前的裝飾器
async def task():
    print('開始了')
    print(current_thread().name)
    await asyncio.sleep(3)  # await等同于原來的yield from
    print('結束了')

async def task2():
    print('開始了')
    print(current_thread().name)
    await asyncio.sleep(2)
    print('結束了')

loop=asyncio.get_event_loop()

ctime=time.time()
t=[task(),task2()]
loop.run_until_complete(asyncio.wait(t))
loop.close()
print(time.time()-ctime)

 ---40---

標籤：Python

上一篇：python安裝第三方庫太慢，很容易失敗報錯？教你如何提速

下一篇：并發編程——IO模型（重點）