一、守护进程和守护线程

1）守护进程的概念

  1. 什么是守护进程：
  2.     守护： 在主进程代码结束情况下，就立即死掉
  3.     守护进程本质就是一个子进程，该子进程守护着主进程
  4.  
  5. 为何要用守护进程
  6.     守护进程本质就是一个子进程，所以在主进程需要将任务并发执行的时候需要开启子进程
  7.     当该子进程执行的任务生命周期伴随主进程整个生命周期的时候，就需要将该子进程做成守护的进程

2）创建守护进程

  1. from multiprocessing import Process
  2. import time
  3.  
  4. def task(x):
  5.     print('%s is running' %x)
  6.     time.sleep()
  7.     print('%s is done' % x)
  8.  
  9. if __name__ == '__main__':
  10.     p=Process(target=task,args=('守护进程',))
  11.     p.daemon=True # 必须放到p.start()之前
  12.     p.start()
  13.     time.sleep()
  14.     print('主')

3）守护线程的概念

  1. 主线程要等到该进程内所有非守护线程（子线程）都死掉才算死掉，因为主线程的生命周期
  2. 代表了该进程的生命周期，该进程一定是要等到所有非守护的线程都干完活才应该死掉
  3.  
  4. 可以简单理解为：
  5.     守护线程是要等待该进程内所有非守护的线程都运行完毕才死掉

4）创建守护线程

  1. from threading import Thread
  2. import time
  3.  
  4. def task(x):
  5.     print('%s is running' %x)
  6.     time.sleep()
  7.     print('%s is done' % x)
  8.  
  9. if __name__ == '__main__':
  10.     t=Thread(target=task,args=('守护线程',))
  11.     t.daemon=True # 必须放到p.start()之前
  12.     t.start()
  13.     print('主')

二、互斥锁和信号量与GIL全局解释器锁，死锁及递归锁

1）互斥锁的意义

  1. 互斥锁的原理是将进程/线程内执行的部分代码由并发执行变成穿行执行，牺牲了效率但保证数据安全
  2. 互斥锁不能连续低执行mutex.acquire()操作，必须等到拿着锁的进程释放锁mutex.release()其他进程才能抢到

2）进程mutex=Lock()

  1. from multiprocessing import Process,Lock
  2. import json
  3. import os
  4. import time
  5. import random
  6.  
  7. mutex=Lock()
  8.  
  9. def check():
  10.     with open('db.json','rt',encoding='utf-8') as f:
  11.         dic=json.load(f)
  12.     print('%s 剩余票数：%s' %(os.getpid(),dic['count']))
  13.  
  14. def get():
  15.     with open('db.json','rt',encoding='utf-8') as f:
  16.         dic=json.load(f)
  17.     time.sleep()
  18.     if dic['count']  > :
  19.         dic['count']-=
  20.         time.sleep(random.randint(,)) #模拟网络延迟
  21.         with open('db.json','wt',encoding='utf-8') as f:
  22.             json.dump(dic,f)
  23.             print('%s 抢票成功' %os.getpid())
  24.  
  25. def task(mutex):
  26.     # 并发查看
  27.     check()
  28.     # 串行购票
  29.     mutex.acquire()
  30.     get()
  31.     mutex.release()
  32.  
  33. if __name__ == '__main__':
  34.     for i in range():
  35.         p=Process(target=task,args=(mutex,))
  36.         p.start()
  37.         # p.join() # 将p内的代码变成整体串行

3）信号量。设置能同时执行任务的数量

  1. # 比如公共厕所，能同时上厕所的有4个位置
  2. from multiprocessing import Process,Semaphore
  3. import os
  4. import time
  5. import random
  6.  
  7. sm=Semaphore()
  8.  
  9. def go_wc(sm):
  10.     sm.acquire()
  11.     print('%s is wcing' %os.getpid())
  12.     time.sleep(random.randint(,))
  13.     sm.release()
  14.  
  15. if __name__ == '__main__':
  16.     for i in range():
  17.         p=Process(target=go_wc,args=(sm,))
  18.         p.start()

4）线程问题版。线程中修改同一个数据，数据存在不安全，故障

  1. from threading import Thread
  2. import time
  3. n =
  4. def task():
  5.     global n
  6.     temp = n
  7.     time.sleep(0.1)
  8.     n = temp -
  9.  
  10. if __name__ == '__main__':
  11.     t_l  = []
  12.     for i in range():
  13.         t = Thread(target=task)
  14.         t_l.append(t)
  15.         t.start()
  16.     for t in t_l:
  17.         t.join()
  18.     print(n)

5）线程互斥锁修改版

  1. from threading import Thread,Lock
  2. import time
  3.  
  4. mutex = Lock()
  5. n =
  6. def task():
  7.     global n
  8.     with mutex:     # 拿到锁，自动释放锁
  9.         temp = n
  10.         time.sleep(0.1)
  11.         n = temp -
  12.  
  13. if __name__ == '__main__':
  14.     t_l = []
  15.     start_time = time.time()
  16.     for i in range():
  17.         t = Thread(target=task)
  18.         t_l.append(t)
  19.         t.start()
  20.     for t in t_l:
  21.         t.join()
  22.     print(n)
  23.     print(time.time()- start_time)

6）GIL的意义。判断什么情况下使用线程和进程

  1.  GIL是什么
  2.     GIL是全局解释器锁，本质就是一把互斥锁
  3.     GIL是Cpython解释器的特性，而不是python的特性
  4.     每启动一个进程，该进程就会有一个GIL锁，用来控制该进程内的多个线程同一时间只有一个执行
  5.     这意味着Cpython解释器的多线程没有并行的效果，但是有并发的效果
  6.  
  7. 、为什么要有GIL
  8.     因为Cpython解释器的垃圾回收机制不是线程安全的
  9.  
  10. 、GIL vs 自定义互斥锁
  11.     在一个进程内的多个线程要想执行，首先需要抢的是GIL，GIL就相当于执行权限
  12.  
  13.     python的多进程用于计算密集型
  14.     python的多线程用于IO密集型

7）计算密集型中，进程计算和线程计算对比

进程计算，计算密集型。利用多核cpu的优势，但进程数不能超过核数的2倍，会大量消耗cpu资源。计算时间  27.400567293167114

  1. from multiprocessing import Process
  2. import time
  3.  
  4. def task1():
  5.     res=
  6.     for i in range():
  7.         res*=i
  8.  
  9. def task2():
  10.     res =
  11.     for i in range():
  12.         res += i
  13.  
  14. def task3():
  15.     res =
  16.     for i in range():
  17.         res -= i
  18.  
  19. def task4():
  20.     res =
  21.     for i in range():
  22.         res += i
  23.  
  24. if __name__ == '__main__':
  25.     start_time=time.time()
  26.     p1=Process(target=task1)
  27.     p2=Process(target=task2)
  28.     p3=Process(target=task3)
  29.     p4=Process(target=task4)
  30.  
  31.     p1.start()
  32.     p2.start()
  33.     p3.start()
  34.     p4.start()
  35.  
  36.     p1.join()
  37.     p2.join()
  38.     p3.join()
  39.     p4.join()
  40.     stop_time=time.time()
  41.     print(stop_time-start_time) #27.400567293167114

计算密集型任务用多进程

线程进行密集计算。计算时间 86.84396719932556

  1. import time
  2. from threading import Thread
  3. def task1():
  4.     res=
  5.     for i in range():
  6.         res*=i
  7.  
  8. def task2():
  9.     res =
  10.     for i in range():
  11.         res += i
  12.  
  13. def task3():
  14.     res =
  15.     for i in range():
  16.         res -= i
  17.  
  18. def task4():
  19.     res =
  20.     for i in range():
  21.         res += i
  22.  
  23. if __name__ == '__main__':
  24.     start_time=time.time()
  25.     p1=Thread(target=task1)
  26.     p2=Thread(target=task2)
  27.     p3=Thread(target=task3)
  28.     p4=Thread(target=task4)
  29.  
  30.     p1.start()
  31.     p2.start()
  32.     p3.start()
  33.     p4.start()
  34.  
  35.     p1.join()
  36.     p2.join()
  37.     p3.join()
  38.     p4.join()
  39.     stop_time=time.time()
  40.     print(stop_time-start_time) # 86.84396719932556

8）IO密集型中。进程与线程对比

进程完成时间 3.5172011852264404

  1. import time
  2. from multiprocessing import Process
  3. def task1():
  4.     time.sleep()
  5. def task2():
  6.     time.sleep()
  7.  
  8. def task3():
  9.     time.sleep()
  10.  
  11. def task4():
  12.     time.sleep()
  13.  
  14. if __name__ == '__main__':
  15.     start_time=time.time()
  16.     p1=Process(target=task1)
  17.     p2=Process(target=task2)
  18.     p3=Process(target=task3)
  19.     p4=Process(target=task4)
  20.  
  21.     p1.start()
  22.     p2.start()
  23.     p3.start()
  24.     p4.start()
  25.  
  26.     p1.join()
  27.     p2.join()
  28.     p3.join()
  29.     p4.join()
  30.     stop_time=time.time()
  31.     print(stop_time-start_time) # 3.5172011852264404

线程优势，完成时间 3.003171443939209

  1. import time
  2. from threading import Thread
  3. def task1():
  4.     time.sleep()
  5. def task2():
  6.     time.sleep()
  7.  
  8. def task3():
  9.     time.sleep()
  10.  
  11. def task4():
  12.     time.sleep()
  13.  
  14. if __name__ == '__main__':
  15.     start_time=time.time()
  16.     p1=Thread(target=task1)
  17.     p2=Thread(target=task2)
  18.     p3=Thread(target=task3)
  19.     p4=Thread(target=task4)
  20.  
  21.     p1.start()
  22.     p2.start()
  23.     p3.start()
  24.     p4.start()
  25.  
  26.     p1.join()
  27.     p2.join()
  28.     p3.join()
  29.     p4.join()
  30.     stop_time=time.time()
  31.     print(stop_time-start_time) # 3.003171443939209

9）死锁现象。释放锁之前，都需要获取到对方的锁，造成了无法释放锁

  1. from threading import Thread,Lock
  2. import time
  3. mutexA = Lock()
  4. mutexB = Lock()
  5.  
  6. class Mythread(Thread):
  7.     def run(self):
  8.         self.f1()
  9.         self.f2()
  10.  
  11.     def f1(self):
  12.         mutexA.acquire()
  13.         print('%s 抢到了A锁' %self.name)
  14.  
  15.         mutexB.acquire()
  16.         print('%s 抢到了B锁' % self.name)
  17.         mutexB.release()
  18.  
  19.         mutexA.release()
  20.     def f2(self):
  21.         mutexB.acquire()
  22.         print('%s 抢到了B锁' % self.name)
  23.         time.sleep()
  24.  
  25.         mutexA.acquire()
  26.         print('%s 抢到了A锁' % self.name)
  27.         mutexA.release()
  28.  
  29.         mutexB.release()
  30.  
  31. if __name__ == '__main__':
  32.     for i in range():
  33.         t =  Mythread()
  34.         t.start()

10）递归锁。RLock，解决死锁现象。递归锁可以连续acquire()

  1. from threading import Thread,RLock
  2. import time
  3. mutexA = mutexB = RLock()
  4. class Mythread(Thread):
  5.     def run(self):
  6.         self.f1()
  7.         self.f2()
  8.  
  9.     def f1(self):
  10.         mutexA.acquire()
  11.         print('%s 抢到了A锁' %self.name)
  12.  
  13.         mutexB.acquire()
  14.         print('%s 抢到了B锁' % self.name)
  15.         mutexB.release()
  16.  
  17.         mutexA.release()
  18.     def f2(self):
  19.         mutexB.acquire()
  20.         print('%s 抢到了B锁' % self.name)
  21.         time.sleep()
  22.  
  23.         mutexA.acquire()
  24.         print('%s 抢到了A锁' % self.name)
  25.         mutexA.release()
  26.  
  27.         mutexB.release()
  28.  
  29. if __name__ == '__main__':
  30.     for i in range():
  31.         t =  Mythread()
  32.         t.start()

三、IPC机制或队列和生产者模型

IPC:进程间通信，有两种解决方案：队列、管道

1）队列，先进先出。应用于生产者模型

  1. from multiprocessing import Queue
  2. q=Queue(maxsize=)
  3.  
  4. q.put({'x':})
  5. q.put()
  6. q.put('third')
  7.  
  8. print(q.get())
  9. print(q.get())
  10. print(q.get())

默认不加参数，超过队列最大值会堵塞。 q.put(1,block=False)  超过最大值，程序中断。效果等同于 q.put_nowait(1)。

timeout=3 超时时间，block=True的时候，才有意义

2）生产者模型的意义

  1. 、什么是生产者消费者模型
  2.     生产者消费者模型指的是一种解决问题的思路
  3.     该模型中包含两类明确的角色：
  4.         、生产者：创造数据的任务
  5.         、消费者：处理数据的任务
  6.  
  7. 、为什么要用生产者消费者模型？
  8.     、实现生产者与消费者任务的解耦和
  9.     、平衡了生产者的生产力与消费者消费力
  10.     一旦程序中出现明显的两类需要并发执行的任务，一类是负责数据的，另外一类是负责处理数据的
  11.     那么就可以使用生产者消费者模型来提升执行效率
  12.  
  13. 、如何用
  14.     生产者----》队列《-------消费者
  15.     队列
  16.         、队列占用的是内存控制，即便是不指定队列的大小也不可能无限制地放数据
  17.         、队列是用来传递消息的介质，即队列内存放的是数据量较小的数据

2）生产者模型Queue，消费者卡住的不完善版本

  1. from multiprocessing import Queue,Process
  2. import time
  3.  
  4. def producer(name,q):
  5.     for i in range():
  6.         res = '包子%s' %i
  7.         time.sleep(0.5)
  8.         print('\033[45m厨师%s 生成了%s\033[0m' %(name,res))
  9.         q.put(res)
  10.  
  11. def consumer(name,q):
  12.     while True:
  13.         res = q.get()
  14.         time.sleep()
  15.         print('\033[47m吃货%s 吃了%s\033[0m'%(name,res))
  16.  
  17. if __name__ == '__main__':
  18.     q = Queue()
  19.     # 生产者们
  20.     p1 = Process(target=producer,args=('egon',q))
  21.     # 消费者们
  22.     c1 = Process(target=consumer,args=('alex',q))
  23.  
  24.     p1.start()
  25.     c1.start()
  26.     print("主")

3）low版生产者模型Queue，结束信号None

  1. from multiprocessing import Queue,Process
  2. import time
  3.  
  4. def producer(name,food,q):
  5.     for i in range():
  6.         res = '%s%s' %(food,i)
  7.         time.sleep(0.5)
  8.         print('\033[45m厨师%s 生成了%s\033[0m' %(name,res))
  9.         q.put(res)
  10.  
  11. def consumer(name,q):
  12.     while True:
  13.         res = q.get()
  14.         time.sleep()
  15.         print('\033[47m吃货%s 吃了%s\033[0m'%(name,res))
  16.  
  17. if __name__ == '__main__':
  18.     q = Queue()
  19.     # 生产者们
  20.     p1 = Process(target=producer, args=('egon','蛋糕',q))
  21.     p2 = Process(target=producer, args=('lxx','面包' ,q))
  22.     p3 = Process(target=producer, args=('cxx','炸弹' ,q))
  23.     # 消费者们
  24.     c1 = Process(target=consumer,args=('alex',q))
  25.     c2 = Process(target=consumer, args=('wcc', q))
  26.  
  27.     p1.start()
  28.     pfile:/D:/oldboyedu/manth-/day-/tet2.start()
  29.     p3.start()
  30.     c1.start()
  31.     c2.start()
  32.  
  33.     p1.join()
  34.     p2.join()
  35.     p3.join()
  36.  
  37.     q.put(None)
  38.     q.put(None)
  39.     print('主')
  40.     print("主")

4）生产者模型最终版本 JoinableQueue，以守护进程的方式来结束

  1. from multiprocessing import JoinableQueue,Process
  2. import time
  3.  
  4. def producer(name,food,q):
  5.     for i in range():
  6.         res = '%s%s' %(food,i)
  7.         time.sleep(0.5)
  8.         print('\033[45m厨师%s 生成了%s\033[0m' %(name,res))
  9.         q.put(res)
  10.  
  11. def consumer(name,q):
  12.     while True:
  13.         res = q.get()
  14.         time.sleep()
  15.         print('\033[47m吃货%s 吃了%s\033[0m'%(name,res))
  16.         q.task_done()   # 消费者拿了一个，队列就少了一个
  17.  
  18. if __name__ == '__main__':
  19.     q = JoinableQueue()
  20.     # 生产者们
  21.     p1 = Process(target=producer, args=('egon','蛋糕',q))
  22.     p2 = Process(target=producer, args=('lxx','面包' ,q))
  23.     p3 = Process(target=producer, args=('cxx','炸弹' ,q))
  24.     # 消费者们
  25.     c1 = Process(target=consumer,args=('alex',q))
  26.     c2 = Process(target=consumer, args=('wcc', q))
  27.     c1.daemon = True
  28.     c2.daemon = True
  29.     p1.start()
  30.     p2.start()
  31.     p3.start()
  32.     c1.start()
  33.     c2.start()
  34.  
  35.     p1.join()
  36.     p2.join()
  37.     p3.join()   # 此时 3个生产者都已经生产完了
  38.     q.join()    # 、证明生产者都已经完全生产完毕 、队列为空，也就是消费者也消费完毕
  39.     print('主')

四、线程queue

1）队列：先进先出

  1. import queue
  2. q=queue.Queue()
  3. q.put()
  4. q.put()
  5. q.put()
  6. print(q.get())
  7. print(q.get())
  8. print(q.get())

队列

2）堆栈：先进后出

  1. import queue
  2. q=queue.LifoQueue()
  3. q.put()
  4. q.put()
  5. q.put()
  6. print(q.get())
  7. print(q.get())
  8. print(q.get())

堆栈

3）优先级队列：优先级高的优先出来

  1. import queue
  2. q=queue.PriorityQueue()
  3. q.put((,'lxx'))
  4. q.put((,'egon')) #数字代表优先级，数字越小优先级越高
  5. q.put((,'alex'))
  6. print(q.get())
  7. print(q.get())
  8. print(q.get())

优先级队列

五、进程池与线程池

1）池的概念

  1. 、什么进程池、线程池
  2.     池指的一个容器，该容器用来存放进程或线程，存放的数目是一定的
  3.  
  4. 、为什么要用池
  5.     用池是为了将并发的进程或线程数目控制在计算机可承受的范围内
  6.     为何要用进程进池？
  7.         当任务是计算密集型的情况下应该用进程来利用多核优势
  8.     为何要用线程进池？
  9.         当任务是IO密集型的情况下应该用线程减少开销

2）同步与异步

  1. 同步调用 vs 异步调用
  2.     异步调用与同步调用指的是提交任务的两种方式
  3.  
  4.     同步调用：提交完任务后，就在原地等待任务执行完毕，拿到运行结果/返回值后再执行下一行代码
  5.         同步调用下任务的执行是串行执行
  6.  
  7.     异步调用：提交完任务后，不会原地等待任务执行完毕，结果 futrue = p.submit(task,i)，结果记录在内存中， 直接执行下一行代码
  8.         同步调用下任务的执行是并发执行

3）异步进程池

  1. from concurrent.futures import ProcessPoolExecutor
  2. import os
  3. import time
  4. import random
  5.  
  6. def task(x):
  7.     print('%s is running' %os.getpid())
  8.     time.sleep(random.randint(,))
  9.     return x**
  10.  
  11. if __name__ == '__main__':
  12.     p=ProcessPoolExecutor() #不指定参数默认池的大写等于cpu的核数
  13.     futrues = []      # 保存任务返回值
  14.     for i in range():
  15.         futrue = p.submit(task,i)  # 提交任务，异步提交
  16.         futrues.append(futrue)  # 保存任务返回值
  17.     p.shutdown(wait=True)   # 关闭了继续提入口交任务的，wait=True 把进程池的里的事做完，再执行后面的任务
  18.     for futrue in futrues:
  19.         print(futrue.result())   # 输入返回结果值
  20.     print('主')

4）同步进程池

  1. from concurrent.futures import ProcessPoolExecutor
  2. import os
  3. import time
  4. import random
  5.  
  6. def task(x):
  7.     print('%s is running' %os.getpid())
  8.     time.sleep(random.randint(,))
  9.     return x**
  10.  
  11. if __name__ == '__main__':
  12.     p=ProcessPoolExecutor() #不指定参数默认池的大写等于cpu的核数
  13.     for i in range():
  14.         res = p.submit(task,i).result()  # 提交任务，异步提交
  15.         print(res)
  16.     print('主')

　　小结，同步与异步，对于获取任务返回值的方式，在于什么时候 obj.result()。

6）回调函数，进程池，解析任务返回值。add_done_callback(parse)

  1. from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
  2. import os
  3. import time
  4. import requests
  5.  
  6. def get(url):
  7.     print('%s GET %s' %(os.getpid(),url))
  8.     time.sleep()
  9.     response=requests.get(url)
  10.     if response.status_code == :
  11.         res=response.text
  12.         return res
  13.  
  14. def parse(obj):
  15.     res = obj.result()
  16.     print('%s 解析[url]结果是 %s' % (os.getpid(), len(res)))
  17.  
  18. if __name__ == '__main__':
  19.     p=ProcessPoolExecutor()
  20.  
  21.     urls=[
  22.         'https://www.baidu.com',
  23.         'https://www.python.org',
  24.         'https://www.openstack.org',
  25.         'https://www.taobao.com',
  26.         'https://www.jd.com',
  27.     ]
  28.  
  29.     for url in urls:
  30.         p.submit(get,url).add_done_callback(parse)    # 回调函数会在任务运行完毕后自动触发，并且接收该任务对象
  31.  
  32.     print('主',os.getpid())

7）回调函数，线程池，解析任务返回值。add_done_callback(parse)

  1. from concurrent.futures import ThreadPoolExecutor
  2. from threading import current_thread
  3. import time
  4. import random
  5.  
  6. def task(x):
  7.     print('%s is running' %current_thread().getName())
  8.     time.sleep(random.randint(,))
  9.     return x**
  10.  
  11. def parse(obj):
  12.     res=obj.result()
  13.     print('%s 解析的结果为%s' %(current_thread().getName(),res))
  14.  
  15. if __name__ == '__main__':
  16.     t=ThreadPoolExecutor()
  17.     for i in range():
  18.         t.submit(task,i).add_done_callback(parse)

六、补充知识

1）线程event事件。一个线程发了一个信号，另外个线程收到该信号，才能继续执行

  1. from threading import Event,current_thread,Thread
  2. import time
  3.  
  4. event=Event()   # 生成信号事件
  5. def check():
  6.     print('%s 正在检测服务是否正常....' %current_thread().name)
  7.     time.sleep()
  8.     event.set()     # 发送信号
  9.  
  10. def connect():
  11.     print('%s 等待连接...' %current_thread().name)
  12.     event.wait()    # 接收信号
  13.     print('%s 开始连接...' % current_thread().name)
  14.  
  15. if __name__ == '__main__':
  16.     t1=Thread(target=connect)
  17.     t2=Thread(target=connect)
  18.     t3=Thread(target=connect)
  19.  
  20.     c1=Thread(target=check)
  21.  
  22.     t1.start()
  23.     t2.start()
  24.     t3.start()
  25.     c1.start()

2）基于上面内容，设置尝试次数

  1. from threading import Event,current_thread,Thread
  2. import time
  3.  
  4. event=Event()
  5.  
  6. def check():
  7.     print('%s 正在检测服务是否正常....' %current_thread().name)
  8.     time.sleep()
  9.     event.set()
  10.  
  11. def connect():
  12.     count=
  13.     while not event.is_set():
  14.         if count ==  :
  15.             print('尝试的次数过多，请稍后重试')
  16.             return
  17.         print('%s 尝试第%s次连接...' %(current_thread().name,count))
  18.         event.wait()
  19.         count+=
  20.     print('%s 开始连接...' % current_thread().name)
  21.  
  22. if __name__ == '__main__':
  23.     t1=Thread(target=connect)
  24.     t2=Thread(target=connect)
  25.     t3=Thread(target=connect)
  26.  
  27.     c1=Thread(target=check)
  28.  
  29.     t1.start()
  30.     t2.start()
  31.     t3.start()
  32.     c1.start()

七）协程介绍（单线程下并发）

  1. 单线程下实现并发:协程
  2. 并发指的多个任务看起来是同时运行的
  3. 并发实现的本质：切换+保存状态
  4.  
  5. 并发、并行、串行：
  6. 并发：看起来是同时运行，切换+保存状态
  7. 并行：真正意义上的同时运行，只有在多cpu的情况下才能
  8.     实现并行，4个cpu能够并行4个任务
  9.  
  10. 串行：一个人完完整整地执行完毕才运行下一个任务
  11.  
  12. 实现方法：
  13.     基于yield保存状态,实现两个任务直接来回切换,即并发的效果
  14.     PS:如果每个任务中都加上打印,那么明显地看到两个任务的打印是你一次我一次,即并发执行的.

1）gevent模拟单线程并发（协程），from gevent import monkey;monkey.patch_all()，监控IO，实现单线程的并发操作

  1. from gevent import monkey;monkey.patch_all()
  2. import gevent
  3. import time
  4. def eat(name):
  5.     print('%s eat 1' %name)
  6.     time.sleep()
  7.     print('%s eat 2' % name)
  8.  
  9. def play(name):
  10.     print('%s play 1' %name)
  11.     time.sleep()
  12.     print('%s play 2' % name)
  13.  
  14. g1 = gevent.spawn(eat,'egon')
  15. g2 = gevent.spawn(play,'alex')
  16.  
  17. gevent.joinall([g1,g2])

2）DummyThread（单线程的并发：spawn，实现的是假线程）

  1. from gevent import monkey;monkey.patch_all()
  2. from threading import current_thread
  3. import gevent
  4. import time
  5.  
  6. def eat():
  7.     print('%s eat 1' %current_thread().name)
  8.     time.sleep()
  9.     print('%s eat 2' %current_thread().name)
  10.  
  11. def play():
  12.     print('%s play 1' %current_thread().name)
  13.     time.sleep()
  14.     print('%s play 2' % current_thread().name)
  15.  
  16. g1 = gevent.spawn(eat)
  17. g2 = gevent.spawn(play)
  18. print(current_thread().name)
  19. gevent.joinall([g1,g2])

3）socket连接，单线程下的并发，测试连接抗压能力

  1. from gevent import monkey,spawn;monkey.patch_all()
  2. from threading import Thread
  3. from socket import *
  4.  
  5. def talk(conn):
  6.     while True:
  7.         try:
  8.             data=conn.recv()
  9.             if not data:break
  10.             conn.send(data.upper())
  11.         except ConnectionResetError:
  12.             break
  13.     conn.close()
  14.  
  15. def server(ip,port,backlog=):
  16.     s = socket()
  17.     s.bind((ip,port))
  18.     s.listen(backlog)
  19.  
  20.     while True:
  21.         conn, addr = s.accept()
  22.         print(addr)
  23.         # 通信
  24.         g=spawn(talk,conn)
  25.  
  26.     s.close()
  27.  
  28. if __name__ == '__main__':
  29.     spawn(server,'127.0.0.1',).join()
  30.     # server(('127.0.0.1',))

server_spawn

  1. from threading import Thread,current_thread
  2. from socket import *
  3. import os
  4.  
  5. def client():
  6.     client = socket()
  7.     client.connect(('127.0.0.1', ))
  8.  
  9.     while True:
  10.         data = '%s hello' % current_thread().name
  11.         client.send(data.encode('utf-8'))
  12.         res = client.recv()
  13.         print(res.decode('utf-8'))
  14.  
  15. if __name__ == '__main__':
  16.     for i in range():
  17.         t=Thread(target=client)
  18.         t.start()

client_Thread

4）网络IO非堵塞模型，实现单线程的并发。s.setblocking(False)，与from gevent import monkey;monkey.patch_all()的原理一样

  1. from socket import *
  2.  
  3. s = socket()
  4. s.bind(('127.0.0.1',))
  5. s.listen()
  6. s.setblocking(False)
  7.  
  8. r_list=[]
  9. while True:
  10.     try:
  11.         conn, addr = s.accept()
  12.         r_list.append(conn)
  13.  
  14.     except BlockingIOError:
  15.         print('可以去干其他的活了')
  16.         print('rlist: ',len(r_list))
  17.         for conn in r_list:
  18.             try:
  19.                 data=conn.recv()
  20.                 conn.send(data.upper())
  21.             except BlockingIOError:
  22.                 continue

socker_server

  1. from socket import *
  2. import os
  3.  
  4. client = socket()
  5. client.connect(('127.0.0.1', ))
  6.  
  7. while True:
  8.     data='%s say hello' %os.getpid()
  9.     client.send(data.encode('utf-8'))
  10.     res=client.recv()
  11.     print(res.decode('utf-8'))

socker_client

5）网络IO非堵塞模型，修正版，收消息与发消息区分开

  1. from socket import *
  2.  
  3. s = socket()
  4. s.bind(('127.0.0.1',))
  5. s.listen()
  6. s.setblocking(False)
  7.  
  8. r_list=[]
  9. w_list=[]
  10. while True:
  11.     try:
  12.         conn, addr = s.accept()
  13.         r_list.append(conn)
  14.  
  15.     except BlockingIOError:
  16.         print('可以去干其他的活了')
  17.         print('rlist: ',len(r_list))
  18.  
  19.         # 收消息
  20.         del_rlist=[]
  21.         for conn in r_list:
  22.             try:
  23.                 data=conn.recv()
  24.                 if not data:
  25.                     conn.close()
  26.                     del_rlist.append(conn)
  27.                     continue
  28.                 w_list.append((conn,data.upper()))
  29.             except BlockingIOError:
  30.                 continue
  31.             except ConnectionResetError:
  32.                 conn.close()
  33.                 del_rlist.append(conn)
  34.  
  35.         # 发消息
  36.         del_wlist=[]
  37.         for item in w_list:
  38.             try:
  39.                 conn=item[]
  40.                 res=item[]
  41.                 conn.send(res)
  42.                 del_wlist.append(item)
  43.             except BlockingIOError:
  44.                 continue
  45.             except ConnectionResetError:
  46.                 conn.close()
  47.                 del_wlist.append(item)
  48.  
  49.         # 回收无用连接
  50.         for conn in del_rlist:
  51.             r_list.remove(conn)
  52.  
  53.         for item in del_wlist:
  54.             w_list.remove(item)

服务端

  1. from socket import *
  2. import os
  3.  
  4. client = socket()
  5. client.connect(('127.0.0.1', ))
  6.  
  7. while True:
  8.     data='%s say hello' %os.getpid()
  9.     client.send(data.encode('utf-8'))
  10.     res=client.recv()
  11.     print(res.decode('utf-8'))

客户端

6）IO多路复用。select模块优化上面的内容

  1. from socket import *
  2. import select
  3.  
  4. s = socket()
  5. s.bind(('127.0.0.1',))
  6. s.listen()
  7. s.setblocking(False)
  8. # print(s)
  9.  
  10. r_list=[s,]
  11. w_list=[]
  12. w_data={}
  13. while True:
  14.     print('被检测r_list： ',len(r_list))
  15.     print('被检测w_list： ',len(w_list))
  16.     rl,wl,xl=select.select(r_list,w_list,[],) #r_list=[server,conn]
  17.  
  18.     # print('rl: ',len(rl)) #rl=[conn,]
  19.     # print('wl: ',len(wl))
  20.  
  21.     # 收消息
  22.     for r in rl: #r=conn
  23.         if r == s:
  24.             conn,addr=r.accept()
  25.             r_list.append(conn)
  26.         else:
  27.             try:
  28.                 data=r.recv()
  29.                 if not data:
  30.                     r.close()
  31.                     r_list.remove(r)
  32.                     continue
  33.                 # r.send(data.upper())
  34.                 w_list.append(r)
  35.                 w_data[r]=data.upper()
  36.             except ConnectionResetError:
  37.                 r.close()
  38.                 r_list.remove(r)
  39.                 continue
  40.  
  41.     # 发消息
  42.     for w in wl:
  43.         w.send(w_data[w])
  44.         w_list.remove(w)
  45.         w_data.pop(w)

server

  1. from socket import *
  2. import os
  3.  
  4. client = socket()
  5. client.connect(('127.0.0.1', ))
  6.  
  7. while True:
  8.     data='%s say hello' %os.getpid()
  9.     client.send(data.encode('utf-8'))
  10.     res=client.recv()
  11.     print(res.decode('utf-8'))

client

八、目前知识总结，项目篇

python之并发编程进阶篇9的更多相关文章

  1. python之并发编程初级篇8

    一.进程理论 1)进程介绍 .什么是进程 一个正在进行的过程,或者说是一个程序的运行过程 其实进程是对正在运行的程序的一种抽象/概括的说法 进程的概念起源操作系统,进程是操作最核心的概念之一 操作系统 ...

  2. Python并发编程理论篇

    Python并发编程理论篇 前言 其实关于Python的并发编程是比较难写的一章,因为涉及到的知识很复杂并且理论偏多,所以在这里我尽量的用一些非常简明的语言来尽可能的将它描述清楚,在学习之前首先要记住 ...

  3. 【转】Shell编程进阶篇(完结)

    [转]Shell编程进阶篇(完结) 1.1 for循环语句 在计算机科学中,for循环(英语:for loop)是一种编程语言的迭代陈述,能够让程式码反复的执行. 它跟其他的循环,如while循环,最 ...

  4. Python 3 并发编程多进程之进程同步（锁）

    Python 3 并发编程多进程之进程同步(锁) 进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,竞争带来的结果就是错乱,如何控制,就是加锁处理. 1. ...

  5. Python 3 并发编程多进程之守护进程

    Python 3 并发编程多进程之守护进程 主进程创建守护进程 其一:守护进程会在主进程代码执行结束后就终止 其二:守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemo ...

  6. Python 3 并发编程多进程之队列（推荐使用）

    Python 3 并发编程多进程之队列(推荐使用) 进程彼此之间互相隔离,要实现进程间通信(IPC),multiprocessing模块支持两种形式:队列和管道,这两种方式都是使用消息传递的. 可以往 ...

  7. Python 的并发编程

    这篇文章将讲解 Python 并发编程的基本操作.并发和并行是对孪生兄弟,概念经常混淆.并发是指能够多任务处理,并行则是是能够同时多任务处理.Erlang 之父 Joe Armstrong 有一张非常 ...

  8. Python基础—面向对象（进阶篇）

    通过上一篇博客我们已经对面向对象有所了解,下面我们先回顾一下上篇文章介绍的内容: 上篇博客地址:http://www.cnblogs.com/phennry/p/5606718.html 面向对象是一 ...

  9. python之并发编程

    一 背景知识 顾名思义,进程即正在执行的一个过程.进程是对正在运行程序的一个抽象. 进程的概念起源于操作系统,是操作系统最核心的概念,也是操作系统提供的最古老也是最重要的抽象概念之一.操作系统的其他所 ...

随机推荐

  1. 由于html元素加载导致的问题

    js中要求执行的事件是在完全加载完,但由于本地环境测试一直没发现出问题,在上线后由于网络延迟导致元素加载慢,而事件执行完,没达到预期目标. 这时就需要用到属性 readyState readyStat ...

  2. LibreOJ 6282. 数列分块入门 6

    题目链接:https://loj.ac/problem/6282 参考博客:http://www.cnblogs.com/stxy-ferryman/p/8560551.html 这里如果用数组的话元 ...

  3. js前端导出excel：json形式的导出

    第一中形式的导出:主要是表头对应主体数据,json形式的导出 js库文件名称 : table2excel.js这个js库文件是网上找的,并且自己根据自己业务需求把内容改了一下复制到 table2exc ...

  4. POJ-1321.棋盘问题.（回溯）

    做完题之后看了网上的一些题解但是发现他们的解释大部分都是错误的,所以就自己写了一下,笔者能力也有限,有错误之处大家多多指正. 第一次看题的时候以为就是简单的八皇后,但是写了之后发现存在很多问题,比如需 ...

  5. linux同步机制

    很早之前就接触过同步这个概念了,但是一直都很模糊,没有深入地学习了解过,近期有时间了,就花时间研习了一下<linux内核标准教程>和<深入linux设备驱动程序内核机制>这两本 ...

  6. f5故障排除

    1.硬件问题 1)硬盘:查看/var/log/daemon, kern日志,smartctl测试,EUD 2)PSU: 查看LCD报警,/var/log/ltm,EUD等 3)内存:可能导致设备突然重 ...

  7. 分布式大数据多维数据分析(olap)引擎kylin[转]

    Apache Kylin是一个开源的分布式分析引擎,提供Hadoop之上的SQL查询接口及多维分析(OLAP)能力以支持超大规模数据,最初由eBay 开发并贡献至开源社区.它能在亚秒内查询巨大的Hiv ...

  8. Aria2GUI 导出下载 刷新界面，任务消失

    问题1. 2.勾选之后 导出下载 没了,神烦 解决方法解决方法1.点击分享, 2.创建链接 3.然后复制链接到网站,  下面是 下载 工具和 谷歌插件http://www.sdifen.com/ari ...

  9. linux命令学习之：du

    du命令也是查看使用空间的,但是与df命令不同的是Linux du命令是对文件和目录磁盘使用的空间的查看,还是和df命令有一些区别的. 语法 du [选项][文件] 选项 -a或-all 显示目录中个 ...

  10. call指令

    CPU执行call指令时,进行两步操作: 将当前的IP或CS和IP压入栈中; 转移. call指令不能实现短转移,除此之外,call指令实现转移的方法和jmp指令的原理相同. 1)依据位移进行转移的c ...