首页 / 更多教程 / 多并发编程基础之协成

多并发编程基础之协成

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了多并发编程基础之协成，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8959字，纯文字阅读大概需要13分钟。

内容图文

原贴:

https://www.cnblogs.com/gbq-dog/p/10375713.html

今天学习了并发编程中的最后一部分，协程，也是python中区别于java，c等语言中很大不同的一部分

1.协程产生的背景

2.协程的概念

3.yield模拟协程

4.协程中主要的俩个模块

5.协程的应用

开始今日份总结

1.协程产生的背景

　　之前我们学习了线程、进程的概念，了解了在操作系统中进程是资源分配的最小单位,线程是CPU调度的最小单位。按道理来说我们已经算是把cpu的利用率提高很多了。但是我们知道无论是创建多进程还是创建多线程来解决问题，都要消耗一定的时间来创建进程、创建线程、以及管理他们之间的切换。

　　随着我们对于效率的追求不断提高，基于单线程来实现并发又成为一个新的课题，即只用一个主线程（很明显可利用的cpu只有一个）情况下实现并发。这样就可以节省创建线进程所消耗的时间。

　　为此我们需要先回顾下并发的本质：切换+保存状态

　　cpu正在运行一个任务，会在两种情况下切走去执行其他的任务（切换由操作系统强制控制），一种情况是该任务发生了阻塞，另外一种情况是该任务计算的时间过长

多并发编程基础之协成 - 文章图片

　　ps：在介绍进程理论时，提及进程的三种执行状态，而线程才是执行单位，所以也可以将上图理解为线程的三种状态

一：其中第二种情况并不能提升效率，只是为了让cpu能够雨露均沾，实现看起来所有任务都被“同时”执行的效果，如果多个任务都是纯计算的，这种切换反而会降低效率。

二：第一种情况的切换。在任务一遇到io情况下，切到任务二去执行，这样就可以利用任务一阻塞的时间完成任务二的计算，效率的提升就在于此。

　　对于单线程下，我们不可避免程序中出现io操作，但如果我们能在自己的程序中（即用户程序级别，而非操作系统级别）控制单线程下的多个任务能在一个任务遇到io阻塞时就切换到另外一个任务去计算，这样就保证了该线程能够最大限度地处于就绪态，即随时都可以被cpu执行的状态，相当于我们在用户程序级别将自己的io操作最大限度地隐藏起来，从而可以迷惑操作系统，让其看到：该线程好像是一直在计算，io比较少，从而更多的将cpu的执行权限分配给我们的线程。

　　协程的本质就是在单线程下，由用户自己控制一个任务遇到io阻塞了就切换另外一个任务去执行，以此来提升效率。为了实现它，我们需要找寻一种可以同时满足以下条件的解决方案：

#1. 可以控制多个任务之间的切换，切换之前将任务的状态保存下来，以便重新运行时，可以基于暂停的位置继续执行。
#2. 作为1的补充：可以检测io操作，在遇到io操作的情况下才发生切换

2.协程的概念

协程：在其他语言中很少去用，在python中非常重要的点,对于操作系统来说，线程已经是操作系统能够看到的最小单位，操作系统无法感知协程

协程的本质是，就是一条线程分成多份，每一份执行一段代码，多段代码可以在一个线程上来回切换
如果能在一段代码执行，在遇到I/O操作的时候，记录此时的状态，去执行另外一段代码，相当于完成利用协程完成了更加充分利用线程的目的

协程利用切换来规避I/O操作带来的好处

一条线程可以执行多个任务
减少了一个线程的阻塞，帮助线程最大程度的抢占CPU资源
协程由于操作系统不可见，不由操作系统控制吗，协程是用户级，减少I/O操作，提高CPU的计算能力
协程之间永远数据安全，----因为很多协程本质上就是一条线程

在pthon中，协程是非常重要的。

3.yield模拟协程

　　那么现在就用yield来模拟协程，毕竟yield也是可以在代码级别记录状态

#代码如下，yield本质是保存现在的状态，send是调用其他函数
def pro():
    print(1)
    n = yield 'a'
    print(n)
    yield 'b'

def com():
    g = pro()
    a = next(g)
    print(a)
    b = g.send(2)
    print(b)

com()

　　代码执行顺序如下

　　相比于串行的去执行，单纯的用yield只会让时间更长

　　下面用yield测试一下之前用到的生产者消费者模型

#单纯的生产者，消费者模型
import time

def consumer(res):
    '''单纯的处理数据'''
    pass

def producer():
    res =[]
    for i in range(10000000):
        pass
    return res

start = time.time()
res = producer()
consumer(res)
end = time.time()
print(end-start)
#结果
0.347031831741333

#用yield模式尝试

import time

def consumer():
    while True:

        x = yield

def producer():
    g = consumer()
    next(g)
    for i in range(10000000):
        g.send(i)
start = time.time()
#并发的执行任务
producer()
end = time.time()

print(end-start)

#结果
1.8232519626617432

　　可以看出来，单纯线程之间俩个任务的切换时很可浪费时间的，如果数据量大存储数据也是很需要时间的，每一次切换都需要记住当前的状态，切换回去需要读取之前的状态。

　　如果我们遇到I/0操作的时候可以自动切换，并且I/O阻塞时间可以和执行代码共享这段时间，才是真正的提高了程序的执行率，yield只是保存了状态。

　　可以用yield实现一个协程的操作。

4.协程中主要的俩个模块

　　协程中的主要有俩个模块，俩个模块都是第三方模块，既然是第三方模块那就先说明一下，第三方模块的导入方法

方法一：在pycharm中，file—settings—project’xxx’—Project Interpreter—‘+’—搜索要安装的包—InstallPackage
方法二：在cmd中 pip install ‘gevent’ 。pip list 查看已经安装的包目录。pip unistalled ‘’ 卸载已经安装的包

　　这个时候需要俩个第三方模块，一个是gevent，一个是greenlet，不过gevent是greenlet的上层模块，，gevent规避I/O操作，判断程序中的I/O操作，遇到I/O就切换到另一个任务去执行。greenlet主要是俩个任务之间的切换，状态的保存以及读取

4.1 greenlet模块

　　安装：pip3 install greenlet

查看代码

import greenlet

def eat():
    print('eat1')
    g2.switch()
    print('eat2')
    g2.switch()

def sleep():
    print('sleep1')
    g1.switch()
    print('sleep2')

g1 = greenlet.greenlet(eat)
g2 = greenlet.greenlet(sleep)
g1.switch()
#结果
eat1
sleep1
eat2
sleep2

　　greenlet 模块只是记录了状态并且在切换回去的是读取了状态，并没有真正意思的自动规避I/O操作

4.2 gevent模块

　　这个时候就需要了gevent模块了

　　安装：pip3 install gevent

　　Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

#gevent模块的使用方法
g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的

g2=gevent.spawn(func2)

g1.join() #等待g1结束

g2.join() #等待g2结束

#或者上述两步合作一步：gevent.joinall([g1,g2])

g1.value#拿到func1的返回值

先运用最基本的协程函数

import gevent
def eat():
    print('eat1')
    gevent.sleep(1)
    print('eat2')

def sleep():
    print('sleep1')
    gevent.sleep(1)
    print('sleep2')
g1 = gevent.spawn(eat)#实例化一个gevent对象
g2 = gevent.spawn(sleep)#实例化一个gevent对象

gevent.joinall([g1,g2])#监测到有I/O就切换

　　上例gevent.sleep(2)模拟的是gevent可以识别的io阻塞,而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了from gevent import monkey;monkey.patch_all()必须放到被打补丁者的前面，如time，socket模块之前，或者我们干脆记忆成：要用gevent，需要将from gevent import monkey;monkey.patch_all()放到文件的开头。

查看更改后的代码

from gevent import monkey
monkey.patch_all()#用来匹配所有的I/O操作
import gevent
import time
def eat():
    print('eat1')
    time.sleep(1)
    print('eat2')

def sleep():
    print('sleep1')
    time.sleep(1)
    print('sleep2')
g1 = gevent.spawn(eat)#实例化一个gevent对象
g2 = gevent.spawn(sleep)#实例化一个gevent对象

gevent.joinall([g1,g2])#监测到有I/O就切换

　　最后我们来看一下协程的id号，代码如下

from gevent import monkey
monkey.patch_all()
import gevent
import time
from threading import currentThread

def eat():
    print('eat:',currentThread())
    print('eat1')
    time.sleep(1)
    print('eat2')

def sleep():
    print('sleep:',currentThread())
    print('sleep1')
    time.sleep(1)
    print('sleep2')

g1 = gevent.spawn(eat)
g2 = gevent.spawn(sleep)

gevent.joinall([g1,g2])
#结果如下
eat: <_DummyThread(DummyThread-1, started daemon 53379528)>
eat1
sleep: <_DummyThread(DummyThread-2, started daemon 53380480)>
sleep1
eat2
sleep2

　　我们可以用threading.current_thread().getName()来查看每个g1和g2，查看的结果为DummyThread-n，即假线程

多并发编程基础之协成 - 文章图片

5.协程的应用

　　对于协程一般使用比较多的地方为网络I/O以及sleep操作，不过一般我们程序代码基本是不会去使用sleep操作，所以日常用的比较多的就是网络爬虫以及socket.server

5.1 网络爬虫简易

　　看代码

#普通打开方式
import time
from urllib import request

def func(name,url):
    ret =  request.urlopen(url)#获取网页
    with open(name+'.html','wb') as f:
        f.write(ret.read())
url_lst = [
    ('python','https://www.python.org/'),
    ('blog','http://www.cnblogs.com/Eva-J/articles/8324673.html'),
    ('pypi','https://pypi.org/project/pip/'),
    ('blog2','https://www.cnblogs.com/z-x-y/p/9237706.html'),
    ('douban','https://www.douban.com/')
]
start = time.time()
for url_item in url_lst:
    func(*url_item)
end = time.time()
print('普通打开方式',end-start)

#协程打开方式
from gevent import monkey
monkey.patch_all()
import gevent
from urllib import request
import time

def func(name,url):
    ret = request.urlopen(url)
    with open(name+'2.html','wb')as f:
        f.write(ret.read())

url_lst = [
    ('python','https://www.python.org/'),
    ('blog','http://www.cnblogs.com/Eva-J/articles/8324673.html'),
    ('pypi','https://pypi.org/project/pip/'),
    ('blog2','https://www.cnblogs.com/z-x-y/p/9237706.html'),
    ('douban','https://www.douban.com/')
]
start = time.time()
g_list =[]
for url_item in url_lst:
    g = gevent.spawn(func,*url_item)
    g_list.append(g)
gevent.joinall(g_list)
end = time.time()
print('协程打开方式',end-start)

看结果

　　普通打开方式 6.35495924949646
　　协程打开方式 1.931349754333496

　　我们会发现现在在少量的url状况下是这样，如果在大量的代码下，这个时间就会缩减的更多。

补充：这个是我在测试的时候发现的状况，在已有文件，打开文件并重新写入文件内容，耗费的时间会高很多！

在爬虫的时候还是用协程，这样会更快的拿到我们需要的数据并对其作出分析！

5.2 用协程实现socket.server

看代码

#服务端

#服务端
import socket
from gevent import monkey
monkey.patch_all()
import gevent

def talk(conn):
    while True:
        msg = conn.recv(1024).decode()
        conn.send(msg.upper().encode('utf-8'))

sk =socket.socket()
sk.bind(('127.0.0.1',8500))
sk.listen()

while True:
    conn,addr = sk.accept()
    gevent.spawn(talk,conn)

#客户端

import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8500))

while True:
    msg = input('--->').encode('utf-8')
    sk.send(msg)
    recv_msg = sk.recv(1024).decode('utf-8')
    print(recv_msg)

sk.close()

内容总结

以上是互联网集市为您收集整理的多并发编程基础之协成全部内容，希望文章能够帮你解决多并发编程基础之协成所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/840892.html

来源：【匿名】

【上一篇】Feign源码解析系列-那些注解们【下一篇】关于IE的RegExp.exec的问题

更多 ►

【多并发编程基础之协成】教程文章相关的互联网学习教程文章

并发编程-线程池（五）线程池为什么不允许使用Executors创建

一、Executors 线程池创建工具【1】 1、Executors.newCachedThreadPool();说明: 创建的线程池核心线程0 ，最大线程是Integer.MaxValue。线程空闲存活时间1分钟。默认异常拒绝策略，使用SynchronousQueue队特点:每次添加任务如果没有空闲线程就会新建一个线程去执行。　　SynchronousQueue是阻塞队列，加入任务的线程会阻塞住，直到其它线程从中取走任务才会结束阻塞　　线程创建上限近乎无限适用场景：所以它适用于任务加入比...

深入理解并发编程 -- 多线程（二）底层运行原理、线程状态【图】

并发编程 -- 多线程底层运行原理、线程状态作者： Stanley 罗昊多线程 -- 并发编程（一）： https://www.cnblogs.com/StanleyBlogs/p/10890906.html 【转载请注明出处和署名，谢谢！】多线程底层执行原理说道底层运行，那么是不是就是需要依靠CPU啊；那，各位之前有没有听过一句话叫做，一个CPU在同一个时间片只能执行一个程序；什么意思呢？就是，你的程序是不是都运行在一个CPU上啊，那你真正一个CPU在同一个时间片里是...

【并发编程必备基础之进程】 �

原文: http://blog.gqylpy.com/gqy/236 目录 1.操作系统背景知识 2.什么是进程 3.进程调度 4.进程的并行与并发 5.同步异步阻塞非阻塞 6.进程的创建与结束 1.操作系统背景知识顾名思义，进程即正在执行的一个过程，进程是对正在运行的程序的一个抽象。进程的概念起源于操作系统，是操作系统最核心的概念，也是操作系统提供的最古老的最重要的抽象概念之一，操作系统的其他所有内容都是围绕进程的概念展开的。所以想要真正了解...

透彻讲解：并发编程的优缺点

本人免费整理了Java高级资料，涵盖了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo高并发分布式等教程，一共30G，需要自己领取。传送门：https://mp.weixin.qq.com/s/JzddfH-7yNudmkjT0IRL8Q一直以来并发编程对于刚入行的小白来说总是觉得高深莫测，于是乎，就诞生了想写点东西记录下，以提升理解和堆并发编程的认知。为什么需要用的并发？凡事总有好坏两面，之间的trade-off是什么，也就是说并发编程具有哪些缺点...

JUC并发编程（二）【代码】【图】

8锁现象在并发编程中，一直在谈论锁，但是锁到底是什么呢？它锁的是什么？首先看下以下8个问题1、一部手机，两个线程，标准访问，请问先打印邮件还是短信？ 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？ 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？ 4、两部手机、请问先打印邮件还是短信？ 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？ 6、两个静态同步方法，2部手机，请问先打印邮件还是...

并发编程及并发编程的核心【图】

核心：基于资源状态的调度方式的控制权问题：有锁无锁调度线程：基于内核的锁调度；其它：应用层自我调度；并发编程在过去的30年里，计算机的性能是在摩尔定律的推动下，从现在开始，这将由Amdahl定律决定。编写代码，有效地利用多个处理器可以是非常具有挑战性的。" -Doron Rajwan　　 Amdahls Law：每个程序都分为串行与并行部分，降低串行的比重，可提高程序的效率。进行多核多服务器时代，并行并发模式更是对程序员的...

并发编程学习笔记(2)----使用多线程带来的风险【代码】

说到多线程带来的风险，首先要了解一个概念-临界区。什么是临界区？临界区是用来表示一种公共的资源（共享数据），它可以被多个线程使用，但是在每次只能有一个线程能够使用它，当临界区资源正在被一个线程使用时，其他的线程就只能等待当前线程执行完之后才能使用该临界区资源。比如一台饮水机，比如办公室办公室里有一支笔，它一次只能被一个人使用，假如它正在被甲使用时，其他想要使用这支笔的人只能等甲使用完这支笔之后才能允...

【并发编程】（十）线程本地变量的实现——ThreadLocal原理详解【代码】【图】

文章目录 1.ThreadLocal的实现1.1.创建1.2.初始化1.3.移除1.4.存储结构图示1.5.小结 2.ThreadLocalMap的实现2.1.Entry的结构2.1.1.为什么key要使用弱引用2.1.2.为什么value不使用弱引用 2.2.Entry初始化2.2.1.模拟魔数的使用2.2.2.ThreadLocal是如何使用魔数的2.2.3.数组下标出现重复的情况 2.3.set()方法2.3.1.set()方法源码解析2.3.1.1.开放寻址法——解决Hash冲突 2.3.2.扩容 2.4.get()方法2.5.remove()方法 3.总结 1.ThreadLoc...

JUC并发编程(基础入门七)——JMM、volatile、禁止指令重排【代码】【图】

1 JMM 1对Volatile 的理解 Volatile 是 Java 虚拟机提供轻量级的同步机制 1、保证可见性 2、不保证原子性 3、禁止指令重排如何实现可见性 volatile变量修饰的共享变量在进行写操作的时候回多出一行汇编： 0x01a3de1d:movb $00，01104800（%esi）;0x01a3de24**:lock** addl $00,(%esp); Lock前缀的指令在多核处理器下会引发两件事情。 1）将当前处理器缓存行的数据写回到系统内存。 2）这个写回内存的操作会使其他cpu里缓存了该内...

并发编程之GIL锁

并发编程之GIL锁 1.定义 ? GIL(Global_Interpreter_Lock)全局解释器锁: ? 在cpython中,GIL是一个互斥锁,为了防止多个本地线程在同一时间执行python字节码,因为cpython中的内存管理是非线程安全的,而cpython中的很多特性都依赖于这个特性. 2.cpython解释器与python程序之间的关系python程序本质就是一堆字符串,所以运行一个python程序时必须要开启开启一个解释器但是在一个python程序中解释器只有一个所有代码都要交给它来解释执...