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

一丶同步,异步

同步:

   所谓同步就是一个任务需要依赖另一个任务时,只有被依赖任务执行完毕之后,依赖的任务才会完成.这是可靠的任务序列.要么都成功,要么失败,两个任务的状态可以保持一致.

异步:

   所谓异步不需要等待被依赖的任务完成,只是通知依赖的任务要完成什么工作.依赖的任务也立即执行,只要自己完成了整个任务就算完成了. 至于被依赖的任务是否完成,依赖它的任务无法确定,是不可靠的任务序列

  1. ### 同步和异步
  2. ## 比如我去银行办理业务，可能会有两种方式：
  3. # 第一种 ：选择排队等候；
  4. # 第二种 ：选择取一个小纸条上面有我的号码，等到排到我这一号时由柜台的人通知我轮到我去办理业务了；
  6. # 第一种：前者(排队等候)就是同步等待消息通知，也就是我要一直在等待银行办理业务情况；
  8. # 第二种：后者(等待别人通知)就是异步等待消息通知。在异步消息处理中，等待消息通知者(在这个例子中就是等待办理业务的人)往往注册一个回调机制，在所等待的事件被触发时由触发机制(在这里是柜台的人)通过某种机制(在这里是写在小纸条上的号码，喊号)找到等待该事件的人。

二丶阻塞,非阻塞,

   阻塞和非阻塞两个概念与程序(也就是执行程序的'线程')等待消息通知时的状态相关

阻塞:

   在程序中,阻塞代表程序'卡'在某处,必须等待这处执行完毕才能继续执行.通常的阻塞大多数是IO阻塞

   比如:银行排队取钱是一条流水线,现在负责取钱的服务人员饿了,他必须吃饭(阻塞). 只有吃完饭才能继续回来服务你.此时你就必须等待他,否则你将无法取钱.对于程序而言,就卡在了此处.

非阻塞:

   非阻塞就是没有IO阻塞,线程在执行任务时没有遇到IO阻塞.

   比如:你去银行取钱,在排队'等候'时什么事情都没有发生. 强调在执行的过程

​

同步阻塞:

   效率最低.你排着队取钱,服务人员吃饭去了(阻塞了),此时你只能等待,否则不能取钱.这就是同步+阻塞

异步阻塞:

   在银行等待办理业务的人,采用异步方式. 但是他不能离开银行

   异步操作是可以被阻塞住的，只不过它不是在处理消息时阻塞，而是在等待消息通知时被阻塞。

同步非阻塞:

   实际上是效率低下的。

   想象一下你一边打着电话一边还需要抬头看到底队伍排到你了没有，如果把打电话和观察排队的位置看成是程序的两个操作的话，这个程序需要在这两种不同的行为之间来回的切换，效率可想而知是低下的。

异步非阻塞:

   效率更高

   因为打电话是你(等待者)的事情，而通知你则是柜台(消息触发机制)的事情，程序没有在两种不同的操作中来回切换。

   比如说，这个人突然发觉自己烟瘾犯了，需要出去抽根烟，于是他告诉大堂经理说，排到我这个号码的时候麻烦到外面通知我一下，那么他就没有被阻塞在这个等待的操作上面，自然这个就是异步+非阻塞的方式了。

   很多人会把同步和阻塞混淆，是因为很多时候同步操作会以阻塞的形式表现出来，同样的，很多人也会把异步和非阻塞混淆，因为异步操作一般都不会在真正的IO操作处被阻塞。

三丶异步+回调机制

提高效率版:

  1. #######  并发爬取 , 并发处理爬取结果
  2.         # 缺点: 1.增强了耦合性,
  3.         #      2.开启进程耗费资源
  4.         # 优点: 1. 提高处理效率
  6. from  concurrent.futures import ProcessPoolExecutor
  7. import time
  8. import random
  9. import os
  10. import requests
  12. def get_html(url):
  13.     response=requests.get(url)
  15.     print(f'{os.getpid()} 正在爬取网页~~~')
  17.     if response.status_code==200:
  18.         parser_html(response.text)
  20. def parser_html(obj):
  22.     print(f'总字符长度:{len(obj.result()) }')
  24. if __name__ == '__main__':
  25.     url_list = [
  26.         'http://www.taobao.com',
  27.         'http://www.JD.com',
  28.         'http://www.JD.com',
  29.         'http://www.JD.com',
  30.         'http://www.baidu.com',
  31.         'https://www.cnblogs.com/jin-xin/articles/11232151.html',
  32.         'https://www.cnblogs.com/jin-xin/articles/10078845.html',
  33.         'http://www.sina.com.cn',
  34.         'https://www.sohu.com',
  35.         'https://www.youku.com',
  36.     ]
  37.     pool=ProcessPoolExecutor(4)         # 开启了一个进程池 有4个进程资源
  39.     for url in url_list:
  40.         obj=pool.submit(get_html,url)   #  异步的开启了 10个任务,4个进程并行(并发)执行.
  42.     pool.shutdown(wait=True)    # 必须等待所有的子进程任务执行完毕

降低耦合版本:

  1. # 并发爬取, 串行解析结果
  2. ########### 回调函数 + 异步
  3. 	#  1. 降低了耦合性, 由回调函数 去通知执行下一个任务(造成这个任务会经历串行)
  4. 	#  2. 处理爬取结果时是串行处理,影响效率
  6. import requests
  7. from concurrent.futures import ProcessPoolExecutor
  8. from multiprocessing import Process
  9. import time
  10. import random
  11. import os
  13. def get(url):
  14.     response = requests.get(url)
  15.     print(f'{os.getpid()} 正在爬取:{url}')
  16.     # time.sleep(random.randint(1,3))
  17.     if response.status_code == 200:
  19.         return response.text
  21. def parse(obj):
  22.     '''
  23.     对爬取回来的字符串的分析
  24.     简单用len模拟一下.
  25.     :param text:
  26.     :return:
  27.     '''
  28.     time.sleep(1)
  30.     ### obj.result() 取得结果
  31.     print(f'{os.getpid()} 分析结果:{len(obj.result())}')
  33. if __name__ == '__main__':
  35.     url_list = [
  36.         'http://www.taobao.com',
  37.         'http://www.JD.com',
  38.         'http://www.JD.com',
  39.         'http://www.JD.com',
  40.         'http://www.baidu.com',
  41.         'https://www.cnblogs.com/jin-xin/articles/11232151.html',
  42.         'https://www.cnblogs.com/jin-xin/articles/10078845.html',
  43.         'http://www.sina.com.cn',
  44.         'https://www.sohu.com',
  45.         'https://www.youku.com',
  46.     ]
  47.     start_time = time.time()
  48.     pool = ProcessPoolExecutor(4)
  49.     for url in url_list:
  50.         obj = pool.submit(get, url)
  51.         obj.add_done_callback(parse)  # 增加一个回调函数
  52.         # 现在的进程完成的还是网络爬取的任务,拿到了返回值之后,结果丢给回调函数add_done_callback,
  53.         # 回调函数帮助你分析结果
  54.         # 进程继续完成下一个任务.
  55.     pool.shutdown(wait=True)
  57.     print(f'主: {time.time() - start_time}')

四丶线程队列

   使用 queue 模块

先进先出:FIFO

      Queue

  1. # -*-coding:utf-8-*-
  2. # Author:Ds
  4. import queue
  6. q = queue.Queue(3) # 先进先出队列
  8. q.put(1)
  9. q.put(2)
  10. q.put('123')
  11. # q.put(666)              # 阻塞 卡住了
  12. # q.put(timeout=1)        # 超时1秒报错 queue.Full
  13. # q.put(1,block=False)        # 非阻塞,直接报错 queue.Full
  15. print(q.get())
  16. print(q.get())
  17. print(q.get())
  18. # print(q.get())              #阻塞 卡住
  19. # print(q.get(timeout=1))      #超时1秒报错 queue.Empty
  20. print(q.get(block=False))       #非阻塞,直接报错queue.Empty

先进后出(后进先出):LIFO

      LifoQueue

  1. # -*-coding:utf-8-*-
  2. # Author:Ds
  4. import queue
  6. q = queue.LifoQueue(3) #后进先出队列 (栈)
  8. q.put(1)
  9. q.put(2)
  10. q.put('123')
  11. # q.put(666)              # 阻塞 卡住了
  12. ## q.put(timeout=1)        # 超时1秒报错 queue.Full
  13. ### q.put(1,block=False)        # 非阻塞,直接报错 queue.Full
  15. print(q.get())
  16. print(q.get())
  17. print(q.get())
  18. # print(q.get())              #阻塞 卡住
  19. ## print(q.get(timeout=1))      #超时1秒报错 queue.Empty
  20. ### print(q.get(block=False))       #非阻塞,直接报错queue.Empty
  1. # 使用列表数据结构模拟栈
  2. li=[]
  3. li.append(1) # 后进  添加元素到列表末尾
  4. li.pop()	 # 先出  移除列表末尾元素

优先级队列:

      PriorityQueue

  1. # -*-coding:utf-8-*-
  2. # Author:Ds
  4. import queue
  6. q = queue.PriorityQueue(3)	# 优先级队列
  8. # 放入元组类型()数据, 第一个参数表示优先级别,第二个参数是真实数据
  9. #  数字越低表示优先级越高
  10. q.put((10, '垃圾消息'))
  11. q.put((-9, '紧急消息'))
  12. q.put((3, '一般消息'))
  13. # q.put((3, '我被卡主了 '))              # 卡主了
  14. # q.put((3, '我被卡主了 '),timeout=1)      # 超时报错: queue.Full
  15. q.put((3, '我被卡主了 '),block=False)        # 不阻塞: queue.Full
  17. print(q.get())
  18. print(q.get())
  19. print(q.get())
  20. print(q.get())              #阻塞 卡住
  21. print(q.get(timeout=1))      #超时1秒报错 queue.Empty
  22. print(q.get(block=False))       #非阻塞,直接报错queue.Empty

五丶事件Event

   线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行

方法:

   event.isSet()：返回event的状态值；

   event.wait()：如果 event.isSet()==False将阻塞线程；

   event.set()：设置event的状态值为True,所有阻塞池的线程激活进入就绪状态,等待操作系统调度；

   event.clear()：恢复event的状态值为False

  1. import time
  2. from threading import Thread
  3. from threading import current_thread
  4. from threading import Event
  6. event = Event()  # 默认是False
  7. def task():
  8.     print(f'{current_thread().name} 检测服务器是否正常开启....')
  9.     time.sleep(3)
  10.     event.set()  # 改成了True
  12. def task1():
  13.     print(f'{current_thread().name} 正在尝试连接服务器')
  14.     # event.wait()  #　轮询检测event是否为Ｔrue,当其为True,继续下一行代码. 阻塞.
  15.     event.wait(1)
  16.     # 设置超时时间,如果1s中以内,event改成True,代码继续执行.
  17.     # 设置超时时间,如果超过1s中,event没做改变,代码继续执行.
  18.     print(f'{current_thread().name} 连接成功')
  19. if __name__ == '__main__':
  20.     t1 = Thread(target=task1,)
  21.     t2 = Thread(target=task1,)
  22.     t3 = Thread(target=task1,)
  24.     t = Thread(target=task)
  26.     t.start()
  27.     t1.start()
  28.     t2.start()
  29.     t3.start()

红绿灯Event事件模型:

  1. # _*_coding:utf-8_*_
  2. # Author   :Ds
  3. # CreateTime   2019/5/30 17:54 
  5. import  threading ,time
  6. event=threading.Event() # 声明一个event全局变量
  7. def lighter():
  8.     count=0         #计数
  9.     event.set()     #设置有标志
  10.     while True:        #循环
  11.         if count > 5 and count<10:#    红灯5秒
  12.             event.clear()# 清空标志位
  13.             print("\033[41;1mred light is on...\033[0m")
  14.         elif count>10:  #  绿灯5秒
  15.             event.set()#变绿灯
  16.             count=0 #清空count
  17.         else:
  18.             print('\033[42;1mgreen light is on...\033[0m')
  19.         time.sleep(1)
  20.         count+=1
  22. def car(name):
  23.     while True:
  24.         if event.is_set(): #is_set 判断设置了标志位没有
  25.             print('[%s] running ...'%name)
  26.             time.sleep(1)
  27.         else:
  28.             print(' [%s] see red  light waiting '%name)
  29.             event.wait()
  30.             print('\033[43;lm [%s] green light  is on  ,start going ..\033[0m'%name)
  32. light=threading.Thread(target=lighter,)
  33. car1=threading.Thread(target=car,args=('特斯拉',))
  34. car2=threading.Thread(target=car,args=('奔驰',))
  35. light.start()
  36. car1.start()
  37. car2.start()

六丶协程

   进程是资源分配的最小单位,线程是CPU调度的最小单

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

线程也具有三个状态:

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

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

yield模拟并发:

      1. yiled可以保存状态，yield的状态保存与操作系统的保存线程状态很像，但是yield是代码级别控制的，更轻量级

      2. send可以把一个函数的结果传给另外一个函数，以此实现单线程内程序之间的切换

   一：其中第二种情况并不能提升效率，只是为了让cpu能够雨露均沾，实现看起来所有任务都被“同时”执行的效果，如果多个任务都是纯计算的，这种切换反而会降低效率。为此我们可以基于yield来验证。yield本身就是一种在单线程下可以保存任务运行状态的方法，我们来简单复习一下：

  1. '''
  2. 1、协程：
  3.     单线程实现并发
  4.     在应用程序里控制多个任务的切换+保存状态
  5.     优点：
  6.         应用程序级别速度要远远高于操作系统的切换
  7.     缺点：
  8.         多个任务一旦有一个阻塞没有切，整个线程都阻塞在原地
  9.         该线程内的其他的任务都不能执行了
  11.         一旦引入协程，就需要检测单线程下所有的IO行为,
  12.         实现遇到IO就切换,少一个都不行，以为一旦一个任务阻塞了，整个线程就阻塞了，
  13.         其他的任务即便是可以计算，但是也无法运行了
  15. 2、协程序的目的：
  16.     想要在单线程下实现并发
  17.     并发指的是多个任务看起来是同时运行的
  18.     并发=切换+保存状态
  19. '''
  21. #串行执行
  22. import time
  24. def func1():
  25.     for i in range(10000000):
  26.         i+1
  28. def func2():
  29.     for i in range(10000000):
  30.         i+1
  32. start = time.time()
  33. func1()
  34. func2()
  35. stop = time.time()
  36. print(stop - start)
  38. #基于yield并发执行
  39. import time
  40. def func1():
  41.     while True:
  42.         yield
  44. def func2():
  45.     g=func1()
  46.     for i in range(10000000):
  47.         i+1
  48.         next(g)
  50. start=time.time()
  51. func2()
  52. stop=time.time()
  53. print(stop-start)
  55. #  单纯地切换反而会降低运行效率

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

  1. import time
  2. def func1():
  3.     while True:
  4.         print('func1')
  5.         yield
  7. def func2():
  8.     g=func1()
  9.     for i in range(10000000):
  10.         i+1
  11.         next(g)
  12.         time.sleep(3)
  13.         print('func2')
  14. start=time.time()
  15. func2()
  16. stop=time.time()
  17. print(stop-start)
  19. yield不能检测IO，实现遇到IO自动切换

协程介绍:

   协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。

   一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。

需要强调的是:

  1. #1. python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）
  2. #2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）

优点如下：

   1.协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级

​   2.单线程内就可以实现并发的效果，最大限度地利用cpu

缺点如下：

   1.协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程

​   2.协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

总结协程特点：

   1.必须在只有一个单线程里实现并发

​   2.修改共享数据不需加锁

   3.用户程序里自己保存多个控制流的上下文栈

   4.附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

Greenlet模块:手动模拟切换

   安装 ：pip3 install greenlet

      手动实现切换

  1. from greenlet import greenlet
  3. def eat(name):
  4.     print('%s eat 1' %name)
  5.     g2.switch('egon')
  6.     print('%s eat 2' %name)
  7.     g2.switch()
  8. def play(name):
  9.     print('%s play 1' %name)
  10.     g1.switch()
  11.     print('%s play 2' %name)
  13. g1=greenlet(eat)
  14. g2=greenlet(play)
  16. g1.switch('egon')	#可以在第一次switch时传入参数，以后都不需要

      效率对比:

         greenlet只是提供了一种比generator更加便捷的切换方式，当切到一个任务执行时如果遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提升效率的问题。

  1. ### 串行执行计算密集型~~  11.37856674194336
  2. import time
  3. def f1():
  4.     res=1
  5.     for i in range(100000000):
  6.         res+=i
  8. def f2():
  9.     res=1
  10.     for i in range(100000000):
  11.         res*=i
  13. start_time=time.time()
  14. f1()
  15. f2()
  16. print(f'runing time {time.time()-start_time}')  # runing time 11.37856674194336
  18. ### 切换执行计算密集型~~  runing time 60.24287223815918
  19. from greenlet import greenlet
  20. import time
  21. def f1():
  22.     res=1
  23.     for i in range(100000000):
  24.         res+=i
  25.         g2.switch()
  27. def f2():
  28.     res=1
  29.     for i in range(100000000):
  30.         res*=i
  31.         g1.switch()
  33. start_time=time.time()
  34. g1=greenlet(f1)
  35. g2=greenlet(f2)
  36. g1.switch()
  37. print(f'runing time {time.time()-start_time}')	# runing time 60.24287223815918

Gevent模块:

​   安装：pip3 install gevent

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

  1. ###  用法
  2. g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的
  4. g2=gevent.spawn(func2)
  6. g1.join() #等待g1结束
  8. g2.join() #等待g2结束
  10. #或者上述两步合作一步：gevent.joinall([g1,g2])
  12. g1.value#拿到func1的返回值

​   遇到IO阻塞时会自动切换任务

  1. import gevent
  2. def eat(name):
  3.     print('%s eat 1' %name)
  4.     gevent.sleep(2)
  5.     print('%s eat 2' %name)
  7. def play(name):
  8.     print('%s play 1' %name)
  9.     gevent.sleep(1)
  10.     print('%s play 2' %name)
  12. g1=gevent.spawn(eat,'egon')
  13. g2=gevent.spawn(play,name='egon')
  14. g1.join()
  15. g2.join()
  16. #或者gevent.joinall([g1,g2])
  17. print('主')

   '打补丁:monkey'

  1. # from gevent import monkey
  2. # monkey.patch_all()	必须放到被打补丁者的前面，
  4. import threading
  5. from gevent import monkey
  6. monkey.patch_all()   	# 打补丁,自动切换
  8. import gevent
  9. import time
  10. def eat():
  11.     print(threading.current_thread().getName())	# 虚拟线程 DummyThread-n
  12.     print('eat food 1')
  13.     time.sleep(2)
  14.     print('eat food 2')
  16. def play():
  17.     print(threading.current_thread().getName())	# 虚拟线程 DummyThread-n
  18.     print('play 1')
  19.     time.sleep(1)
  20.     print('play 2')
  22. g1=gevent.spawn(eat)
  23. g2=gevent.spawn(play)
  24. gevent.joinall([g1,g2])		# 执行g1 g2
  26. print(threading.current_thread().getName())		# MainThread 主线程
  27. print('主')

   协程应用:爬虫:

  1. from gevent import monkey;monkey.patch_all()
  2. import gevent
  3. import requests
  4. import time
  6. def get_page(url):
  7.     print('GET: %s' %url)
  8.     response=requests.get(url)
  9.     if response.status_code == 200:
  10.         print('%d bytes received from %s' %(len(response.text),url))
  12. start_time=time.time()
  13. gevent.joinall([
  14.     gevent.spawn(get_page,'https://www.python.org/'),
  15.     gevent.spawn(get_page,'https://www.yahoo.com/'),
  16.     gevent.spawn(get_page,'https://github.com/'),
  17. ])
  18. stop_time=time.time()
  19. print('run time is %s' %(stop_time-start_time))			# 使用协程爬取,计算爬取的时间

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

  1. (17)线程队列---queue LifoQueue PriorityQueue

    线程常用队列有: queue LifoQueue PriorityQueue 语法: 大致和进程队列语法一致 put 往队列当中放值,超过队列长度,直接加阻塞 get 如果获取不到加阻塞 put_no ...

  2. Python并发编程系列之常用概念剖析：并行 串行 并发 同步 异步 阻塞 非阻塞 进程 线程 协程

    1 引言 并发.并行.串行.同步.异步.阻塞.非阻塞.进程.线程.协程是并发编程中的常见概念,相似却也有却不尽相同,令人头痛,这一篇博文中我们来区分一下这些概念. 2 并发与并行 在解释并发与并行之前 ...

  3. python 之 并发编程（进程池与线程池、同步异步阻塞非阻塞、线程queue）

    9.11 进程池与线程池 池子使用来限制并发的任务数目,限制我们的计算机在一个自己可承受的范围内去并发地执行任务 池子内什么时候装进程:并发的任务属于计算密集型 池子内什么时候装线程:并发的任务属于I ...

  4. 进程&线程 同步异步&阻塞非阻塞

    2015-08-19 15:23:38 周三 线程 线程安全 如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码 线程安全问题都是由全局变量及静态变量引起的 若每个线程中对 ...

  5. Python番外之 阻塞非阻塞，同步与异步，i/o模型

    1. 概念理解 在进行网络编程时,我们常常见到同步(Sync)/异步(Async),阻塞(Block)/非阻塞(Unblock)四种调用方式: 同步/异步主要针对C端: 同步:      所谓同步,就 ...

  6. Python并发编程之同步\异步and阻塞\非阻塞

    一.什么是进程 进程: 正在进行的一个过程或者说一个任务.而负责执行任务则是cpu. 进程和程序的区别: 程序仅仅只是一堆代码而已,而进程指的是程序的运行过程. 需要强调的是:同一个程序执行两次,那也 ...

  7. Python之路(第三十六篇)并发编程：进程、同步异步、阻塞非阻塞

    一.理论基础 进程的概念起源于操作系统,是操作系统最核心的概念,也是操作系统提供的最古老也是最重要的抽象概念之一.操作系统的其他所有内容都是围绕进程的概念展开的. 即使可以利用的cpu只有一个(早期的 ...

  8. {Python之进程} 背景知识 什么是进程 进程调度 并发与并行 同步\异步\阻塞\非阻塞 进程的创建与结束 multiprocess模块 进程池和mutiprocess.Poll

    Python之进程 进程 本节目录 一 背景知识 二 什么是进程 三 进程调度 四 并发与并行 五 同步\异步\阻塞\非阻塞 六 进程的创建与结束 七 multiprocess模块 八 进程池和mut ...

  9. GIL 线程池 进程池 同步 异步 阻塞 非阻塞

    1.GIL 是一个全局解释器锁,是一种互斥锁 为什么需要GIL锁:因为一个python.exe进程中只有一份解释器,如果这个进程开启了多个线程都要执行代码 多线程之间要竞争解释器,一旦竞争就有可能出现 ...

随机推荐

  1. 「SAP技术」SAP MM 事务代码ME17的用法

    SAP MM 事务代码ME17的用法 1,如下采购信息记录需要被归档: PIR号码,5300007816   2, ME12打上删除标记,   3, 事务代码ME17做归档 3.1 创建archive ...

  2. [b0029] python 归纳 (十四)_队列Queue实现生产者消费者

    # -*- coding: UTF-8 -*- """ 多线程的生产者,消费者 使用队列Queue """ import Queue imp ...

  3. 去掉没用的参数的warning

    #define UNUSED(x) ((void)(x)) void fun(int noused_arg, int b){ UNUSED(noused_arg); printf("%d\n ...

  4. 码云 git 常用命令

    git 常用命令: git init 创建一个本地文件 ①git add . 当前文件夹下的所有内容 添加到暂存区 git add test.txt 指定文件夹添加 可以添压缩文件 ②git comm ...

  5. [Linux] deepin系统添加PHP仓库源出错Error: could not find a distribution template for Deepin/stable

    aptsources.distro.NoDistroTemplateException: Error: could not find a distribution template for Deepi ...

  6. 01 less的使用

    使用less 安装两个包 1===>cnpm install less less-loader --save-dev less中的注释 以 //开头的注释 不会被编译到css文件中去 以 /** ...

  7. angular跳转和传参

    使用routerLink跳转 <a routerLink=["/exampledetail",id]></a> <a routerLink=[&quo ...

  8. 第九章 基于HTTP的功能追加协议

    第九章 基于HTTP的功能追加协议 通过在HTTP的基础上添加新的功能来提高性能和功能. 一.消除HTTP瓶颈的SPDY SPDY(SPeeDY)目的是提高HTTP性能,缩短Web页面的加载时间(50 ...

  9. Kafka为什么不支持读写分离得原因？-干货

    在 Kafka 中,出产者写入音讯.顾客读取音讯的操作都是与 leader 副本进行交互的,从 而结束的是一种主写主读的出产消费模型.数据库.Redis 等都具有主写主读的功用,与此同时还支撑主写从读 ...

  10. ASP.NET开发实战——（九）ASP.NET MVC 与数据库之ORM

    之前的文章中介绍了如何在ASP.NET中通过ADO.NET操作SQL Server和My SQL数据库,数据库的操作是通过SQL语句的执行来完成的,在ASP.NET中还有一个简便的方式来使用数据库,那 ...