# 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. Bootstrap 栅格 样式 组件 插件

    -----------------------------起先是我们造成习惯,后来是习惯造成我们. day 51 Bootstrap  官方网站:   bootcss.com/ <!DOCTYP ...

  2. Leetcode 143. Reorder List（Medium）

    Given a singly linked list L: L0→L1→…→Ln-1→Ln,reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→… You must do thi ...

  3. 牛客---java练习

    一. 1. abstract可以修饰方法和类,不能修饰属性.抽象方法没有方法体,即没有大括号{}.抽象类中的成员属性都是public static final类型的:成员方法都是public abst ...

  4. 微信小程序学习笔记以及VUE比较

    之前只是注册了一下微信小程序AppID,随便玩了玩HelloWorld!(项目起手式),但是最近看微信小程序/小游戏,崛起之势不可阻挡.小程序我来了!(果然,一入前端深似海啊啊啊啊啊~) 编辑器: S ...

  5. 原生jS之-去掉字符串开头和结尾的空字符

    怎么解决这个问题?? 思路就是我们利用正则匹配到所谓的空格,然后替换为空字符,我们要用到的是str的replace API 代码如下: <!DOCTYPE html> <html l ...

  6. elasticsearch聚合操作——本质就是针对搜索后的结果使用桶bucket（允许嵌套）进行group by，统计下分组结果，包括min/max/avg

    分析 Elasticsearch有一个功能叫做聚合(aggregations),它允许你在数据上生成复杂的分析统计.它很像SQL中的GROUP BY但是功能更强大. 举个例子,让我们找到所有职员中最大 ...

  7. jquery中ajax使用

    JQuery的Ajax操作,对JavaScript底层Ajax操作进行了封装, <script type="text/javascript"> $.ajax({ url ...

  8. js判断一个对象{}是否为空对象，没有任何属性

    // js如何判断一个对象{}是否为空对象,没有任何属性 if (typeof model.rows === "object" && !(model.rows in ...

  9. linux 服务器名 访问 shh免密码登录

    以根用户登录,或者登录后切换到根用户,然后在提示符下输入hostname命令,可以看出当前系统的主机名为localhost.localdomain.   更改/etc/sysconfig下的netwo ...

  10. js怎么能取得多选下拉框选中的多个值？

    方法:获取多选下拉框对象数组→循环判断option选项的selected属性(true为选中,false为未选中)→使用value属性取出选中项的值.实例演示如下: 1.HTML结构 1 2 3 4 ...