async python异步

但程序异步：

# coding=utf-8
import selenium2
from multiprocessing import Pool
import re
import os
from selenium import webdriver
import queue
import time
import multiprocessing
from pybloom import BloomFilter
import asyncio
from asyncio import Queue


async def foo(myqueue):
    while not myqueue.empty():
        selenium2.mainurl(myqueue.get())
        for this2plusurl in selenium2.linkurl:
            if not this2plusurl in f:
                f.add(this2plusurl)
                ln.append(this2plusurl)
                myqueue.put(this2plusurl)

if __name__ == '__main__':
    global ln
    ln = []
    f = BloomFilter(capacity=100000, error_rate=0.001)
    global myqueue
    myqueue = queue.Queue()
    url = 'qqms.dayanghang.net'
    f.add(url)
    ln.append(url)
    selenium2.mainurl(url)
    for this2plusurl in selenium2.linkurl:
        if not this2plusurl in f:
            f.add(this2plusurl)
            ln.append(this2plusurl)
            myqueue.put(this2plusurl)
    print (myqueue.qsize())
    if not myqueue.empty():
        loop = asyncio.get_event_loop()
        loop.run_until_complete(asyncio.wait(
            [asyncio.async(foo(myqueue))]))
        loop.close()

    print (ln)
    print (myqueue.qsize())

一个产出

import asyncio
from asyncio import Queue  #只能用这个Queue,否则回报错
import time


async def work(myqueue):
    while not myqueue.empty():
        i = await myqueue.get()  #很重要
        try:
            print(i)
            print('q.qsize(): ', myqueue.qsize())
        finally:
            myqueue.task_done()                  #能够顺序的进行下一步


async def run():
    myqueue = Queue()
    await asyncio.wait([myqueue.put(i) for i in range(10)])

#wait后实际是一个迭代器，可以使用函数代替但是要是generator的函数（还不太懂）可以看这个http://stackoverflow.com/questions/37549846/how-to-use-yield-inside-async-function网址
    tasks = [asyncio.ensure_future(work(myqueue))]  #我认为实际上上面的wait是形成了个类似列表的容器

    print('wait join')
    await myqueue.join()      #很重要检查是否堵塞
    print('end join')
    for task in tasks:
        task.cancel()              #有秩序的退出
if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(run())
    loop.close()

二个

import asyncio
from asyncio import Queue


class Test:
    def __init__(self):
        self.que = Queue()
        self.pue = Queue()

    async def consumer(self):
        while True:
            try:
                print('consumer', await self.que.get())
            finally:
                try:
                    self.que.task_done()
                except ValueError:
                    if self.que.empty():
                        print("que empty")

    async def work(self):
        while True:
            try:
                value = await self.pue.get()
                print('producer', value)
                await self.que.put(value)
            finally:
                try:
                    self.pue.task_done()
                except ValueError:
                    if self.pue.empty():
                        print("pue empty")

    async def run(self):
        await asyncio.wait([self.pue.put(i) for i in range(10)])
        tasks = [asyncio.ensure_future(self.work())]
        tasks.append(asyncio.ensure_future(self.consumer()))
        print('p queue join')
        await self.pue.join()
        print('p queue is done & q queue join')
        await self.que.join()
        print('q queue is done')
        for task in tasks:
            task.cancel()
if __name__ == '__main__':
    print('----start----')
    case = Test()
    loop = asyncio.get_event_loop()
    loop.run_until_complete(case.run())
    print('----end----')