# from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor

# import requests

# import os

# import time

# import random

#

# def get(url):

#     print('%s GET %s' %(os.getpid(),url))

#     response=requests.get(url)

#     time.sleep(random.randint(1,3))

#

#     if response.status_code == 200:

#         return response.text

#

# def pasrse(res):

#     print('%s 解析结果为：%s' %(os.getpid(),len(res)))

#

# if __name__ == '__main__':

#     urls=[

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.python.org',

#

#     ]

#

#     pool=ProcessPoolExecutor(4)

#     objs=[]

#     for url in urls:

#         obj=pool.submit(get,url)

#         objs.append(obj)

#

#     pool.shutdown(wait=True)

#     # 问题：

#     # 1、任务的返回值不能得到及时的处理，必须等到所有任务都运行完毕才能统一进行处理

#     # 2、解析的过程是串行执行的,如果解析一次需要花费2s,解析9次则需要花费18s

#     for obj in objs:

#         res=obj.result()

#         pasrse(res)

# from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor

# import requests

# import os

# import time

# import random

#

# def get(url):

#     print('%s GET %s' %(os.getpid(),url))

#     response=requests.get(url)

#     time.sleep(random.randint(1,3))

#

#     if response.status_code == 200:

#         pasrse(response.text)

#

# def pasrse(res):

#     print('%s 解析结果为：%s' %(os.getpid(),len(res)))

#

# if __name__ == '__main__':

#     urls=[

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.python.org',

#

#     ]

#

#     pool=ProcessPoolExecutor(4)

#     for url in urls:

#         pool.submit(get,url)

#

# from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor

# import requests

# import os

# import time

# import random

#

# def get(url):

#     print('%s GET %s' %(os.getpid(),url))

#     response=requests.get(url)

#     time.sleep(random.randint(1,3))

#

#     if response.status_code == 200:

#         # 干解析的活

#         return response.text

#

# def pasrse(obj):

#     res=obj.result()

#     print('%s 解析结果为：%s' %(os.getpid(),len(res)))

#

# if __name__ == '__main__':

#     urls=[

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.baidu.com',

#         'https://www.python.org',

#     ]

#

#     pool=ProcessPoolExecutor(4)

#     for url in urls:

#         obj=pool.submit(get,url)

#         obj.add_done_callback(pasrse)

#

#     # 问题：

#     # 1、任务的返回值不能得到及时的处理，必须等到所有任务都运行完毕才能统一进行处理

#     # 2、解析的过程是串行执行的,如果解析一次需要花费2s,解析9次则需要花费18s

#     print('主进程',os.getpid())

#解决问题：

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor

from threading import current_thread

import requests

import os

import time

import random

def get(url):

    print('%s GET %s' %(current_thread().name,url))

    response=requests.get(url)

    time.sleep(random.randint(1,3))

    if response.status_code == 200:

        # 干解析的活

        return response.text

def pasrse(obj):

    res=obj.result()

    print('%s 解析结果为：%s' %(current_thread().name,len(res)))

if __name__ == '__main__':

    urls=[

        'https://www.baidu.com',

        'https://www.baidu.com',

        'https://www.baidu.com',

        'https://www.baidu.com',

        'https://www.baidu.com',

        'https://www.baidu.com',

        'https://www.baidu.com',

        'https://www.baidu.com',

        'https://www.python.org',

    ]

    pool=ThreadPoolExecutor(4)

    for url in urls:

        obj=pool.submit(get,url)

        obj.add_done_callback(pasrse)

       print('主线程',current_thread().name)

异步+回调机制

线程queue：

1、队列：先进先出

# q=queue.Queue(3) #队列：先进先出

# q.put(1)

# q.put(2)

# q.put(3)

# # q.put(4)

#

# print(q.get())

# print(q.get())

# print(q.get())

队列

2、堆栈：后进先出

# q=queue.LifoQueue(3) #堆栈：后进先出

#

# q.put('a')

# q.put('b')

# q.put('c')

#

# print(q.get())

# print(q.get())

# print(q.get())

堆栈

3、优先级队列：可以以小元组的形式往队列理存值，第一个元素代表优先级，数字越小优先级别越高

q=queue.PriorityQueue(3)

q.put((10,'user1'))

q.put((-3,'user2'))

q.put((-2,'user3'))

print(q.get())

print(q.get())

print(q.get())

优先级队列

Event: 进程之间协同工作

# from threading import Event,current_thread,Thread

# import time

#

# event=Event()

#

# def check():

#     print('%s 正在检测服务是否正常....' %current_thread().name)

#     time.sleep(3)

#     event.set()

#

#

# def connect():

#     print('%s 等待连接...' %current_thread().name)

#     event.wait()

#     print('%s 开始连接...' % current_thread().name)

#

# if __name__ == '__main__':

#     t1=Thread(target=connect)

#     t2=Thread(target=connect)

#     t3=Thread(target=connect)

#

#     c1=Thread(target=check)

#

#     t1.start()

#     t2.start()

#     t3.start()

#     c1.start()

from threading import Event,current_thread,Thread

import time

event=Event()

def check():

    print('%s 正在检测服务是否正常....' %current_thread().name)

    time.sleep(5)

    event.set()

def connect():

    count=1

    while not event.is_set():

        if count ==  4:

            print('尝试的次数过多，请稍后重试')

            return

        print('%s 尝试第%s次连接...' %(current_thread().name,count))

        event.wait(1)

        count+=1

    print('%s 开始连接...' % current_thread().name)

if __name__ == '__main__':

    t1=Thread(target=connect)

    t2=Thread(target=connect)

    t3=Thread(target=connect)

    c1=Thread(target=check)

    t1.start()

    t2.start()

    t3.start()

    c1.start()

Event

协程：

1、单线程下实现并发:协程

　　　　并发指的多个任务看起来是同时运行的

　　　　并发实现的本质：切换+保存状态

　　　　并发、并行、串行：

　　　　并发：看起来是同时运行，切换+保存状态

　　　　并行：真正意义上的同时运行，只有在多cpu的情况下才能

　　　　　　实现并行，4个cpu能够并行4个任务

　　　　串行：一个人完完整整地执行完毕才运行下一个任务

# import time

# def consumer():

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

#     while True:

#         x=yield

#

#

# def producer():

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

#     g=consumer()

#     next(g)

#     for i in range(10000000):

#         g.send(i)

#

# start=time.time()

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

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

# producer() #1.0202116966247559

#

#

# stop=time.time()

# print(stop-start)

#

# import time

# def consumer(res):

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

#     pass

#

# def producer():

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

#     res=[]

#     for i in range(10000000):

#         res.append(i)

#

#     consumer(res)

#     # return res

#

# start=time.time()

# #串行执行

# res=producer()

# stop=time.time()

# print(stop-start)

协程

单线程下实现IO切换：

# from greenlet import greenlet

# import time

#

# def eat(name):

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

#     time.sleep(30)

#     g2.switch('alex')

#     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('egon')

# import gevent

#

# def eat(name):

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

#     gevent.sleep(5)

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

# def play(name):

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

#     gevent.sleep(3)

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

#

# g1=gevent.spawn(eat,'egon')

# g2=gevent.spawn(play,'alex')

#

# # gevent.sleep(100)

# # g1.join()

# # g2.join()

# gevent.joinall([g1,g2])

# from gevent import monkey;monkey.patch_all()

# import gevent

# import time

#

# def eat(name):

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

#     time.sleep(5)

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

# def play(name):

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

#     time.sleep(3)

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

#

# g1=gevent.spawn(eat,'egon')

# g2=gevent.spawn(play,'alex')

#

# # gevent.sleep(100)

# # g1.join()

# # g2.join()

# gevent.joinall([g1,g2])

from gevent import monkey;monkey.patch_all()

from threading import current_thread

import gevent

import time

def eat():

    print('%s eat 1' %current_thread().name)

    time.sleep(5)

    print('%s eat 2' %current_thread().name)

def play():

    print('%s play 1' %current_thread().name)

    time.sleep(3)

    print('%s play 2' %current_thread().name)

g1=gevent.spawn(eat)

g2=gevent.spawn(play)

# gevent.sleep(100)

# g1.join()

# g2.join()

print(current_thread().name)

gevent.joinall([g1,g2])

代码

异步、+回调机制、线程queue、线程Event、协程、单线程实现遇到IO切换的更多相关文章

  1. Python进阶----异步同步,阻塞非阻塞,线程池(进程池)的异步+回调机制实行并发, 线程队列(Queue, LifoQueue,PriorityQueue), 事件Event,线程的三个状态(就绪,挂起,运行) ,***协程概念,yield模拟并发(有缺陷),Greenlet模块(手动切换),Gevent(协程并发)

    Python进阶----异步同步,阻塞非阻塞,线程池(进程池)的异步+回调机制实行并发, 线程队列(Queue, LifoQueue,PriorityQueue), 事件Event,线程的三个状态(就 ...

  2. python并发编程之Queue线程、进程、协程通信（五）

    单线程.多线程之间.进程之间.协程之间很多时候需要协同完成工作,这个时候它们需要进行通讯.或者说为了解耦,普遍采用Queue,生产消费模式. 系列文章 python并发编程之threading线程(一 ...

  3. Python之线程、进程和协程

    python之线程.进程和协程 目录: 引言 一.线程 1.1 普通的多线程 1.2 自定义线程类 1.3 线程锁 1.3.1 未使用锁 1.3.2 普通锁Lock和RLock 1.3.3 信号量(S ...

  4. python线程、进程和协程

    链接:http://www.jb51.net/article/88825.htm 引言 解释器环境:python3.5.1 我们都知道python网络编程的两大必学模块socket和socketser ...

  5. Python菜鸟之路：Python基础-线程、进程、协程

    上节内容,简单的介绍了线程和进程,并且介绍了Python中的GIL机制.本节详细介绍线程.进程以及协程的概念及实现. 线程 基本使用 方法1: 创建一个threading.Thread对象,在它的初始 ...

  6. python 线程，进程与协程

    引言 线程 创建普通多线程 线程锁 互斥锁 信号量 事件 条件锁 定时器 全局解释器锁 队列 Queue:先进先出队列 LifoQueue:后进先出队列 PriorityQueue:优先级队列 deq ...

  7. python队列、线程、进程、协程

    目录: 一.queue 二.线程 基本使用 线程锁 自定义线程池 生产者消费者模型(队列) 三.进程 基本使用 进程锁 进程数据共享 默认数据不共享 queues array Manager.dict ...

  8. python队列、线程、进程、协程(转)

    原文地址: http://www.cnblogs.com/wangqiaomei/p/5682669.html 一.queue 二.线程 #基本使用 #线程锁 #自定义线程池 #生产者消费者模型(队列 ...

  9. day21&22&23：线程、进程、协程

    1.程序工作原理 进程的限制:每一个时刻只能有一个线程来工作.多进程的优点:同时利用多个cpu,能够同时进行多个操作.缺点:对内存消耗比较高当进程数多于cpu数量的时候会导致不能被调用,进程不是越多越 ...

随机推荐

  1. c语言中字符串数组初始化的一点总结&& c++访问控制的三种方式

    char *c[]={"ONE","TWO","THREE","FOUR"}; // c语言中定义了一个字符串数组(也称 ...

  2. java----牛客练习

    1. 形式参数就是函数定义时设定的参数.例如函数头 int min(int x,int y,int z) 中 x,y,z 就是形参.实际参数是调用函数时所使用的实际的参数.   真正被传递的是实参   ...

  3. H5 audio标签

    37-audio标签 注意点: audio标签的使用和video标签的使用基本一样, video中能够使用的属性在audio标签中大部分都能够使用, 并且功能都一样 只不过有3个属性不能用, heig ...

  4. CPU-bound(计算密集型) 和I/O bound(I/O密集型)

    概念 概念I/O系统,英文全称为“Input output system”,中文全称为“输入输出系统”,由输入输出控制系统和外围设备两部分组成,是计算机系统的重要组成部分.在计算机系统中,通常把处理器 ...

  5. CF892.B. Wrath

    ---恢复内容开始--- 题意: 有n个犯人,手上都有个长度为Li的武器,当铃响时大家同时挥动武器,只能把前面攻击范围内的敌人杀死,问最后还剩几个人. 题目传送门: [http://codeforce ...

  6. Day2 Numerical simulation of optical wave propagation之标量衍射理论基本原理(二)

    2.麦克斯韦方程组的简单行波解 讨论通过线性.各向同性.均匀.无色散.无限电荷和电流的电介质材料的光波传输.在这种情况下,介质具有如下属性: (1)推导获得波动方程( 由麦克斯韦方程组导出的.描述电磁 ...

  7. 泛函p121可分Hilbert空间都同构于l^2

    如何理解最后面两句话, L^2与l^2同构 L^2里面 有理系数多项式 是可数稠密子集 所以L^2可分 可分Hilbert空间都同构于 l^2 傅里叶级数是一个稠密的子集

  8. Python classmethod 修饰符

    描述 classmethod修饰符对应的函数不需要实例化,不需要self参数,但第一个参数需要是表示自身类的cls参数,可以调用类的属性,类的方法,实例化对象等. 语法 classmethod语法: ...

  9. 聊一聊跨域，Vue向Django请求数据的一些问题

    1.做前后端分离 前端使用Vue程序,后端使用Django配合rest-framework. 那么前端Vue通过API接口拿到数据会出现跨域的问题,JSONP只是在get中会用到的,所以这里使用cor ...

  10. git rebase的用法

    改变基 一个git库,开发人员在master分支的Bcommit的时候,创建了一个dev分支,此时Bcommit是dev分支的基,然后分别进行两个分支的开发. 进行到master提交了Dcommit, ...