Python档案袋（ 进程与协程 ）

Python的进程和线程是使用的操作系统的原生线程和进程，其是去调用操作系统的相应接口实现

进程：之间不可直接共享数据，是资源的集合，进程必须有一个线程

线程：基于进程，之间可直接共享数据，可执行，只有所有的线程执行完毕程序才会退出

守护线程：生命值依赖于创建它的主线程，主程序亡，不管守护进程执行到何步也必须立即亡

多线程：不适用与CPU操作任务大的（如计算等），较适合于IO操作任务大的（如文件读写等）

进程

简单的进程

在Windows上启动进程必须加入【if __name__=="__main__":】，而在linux上则可随意，进程的使用基本与线程相同

import multiprocessing
import time

def run11():
   print("-----  进程  ----")

# win 进程启动，必须加入这句
if __name__=="__main__":
    #启动进程
   t1=multiprocessing.Process(target=run11,args=())
   t1.start()

进程间传递数据之进程队列：

 import multiprocessing

 def run11(qqlistx):
    print("****** 进入进程 ********")
    #设置进程数据
    qqlistx.put("")

 # win 进程启动，必须加入这句
 if __name__=="__main__":

     #进程队列
     qqlistx = multiprocessing.Queue()

     #启动进程，必须传递进程队列
     t1=multiprocessing.Process(target=run11,args=(qqlistx,))
     t1.start()

     print("得到进程数据：", qqlistx.get())

进程间传递数据之管道：

 import multiprocessing

 def run11(pp1):
    print("****** 进入进程 ********")

    #发送数据
    pp1.send("东小东")
    print("收到mian进程发来的数据：",pp1.recv())

 # win 进程启动，必须加入这句
 if __name__=="__main__":

     #得到管道
     # 得到两端，如同socket的服务器和客户端
     #任意一端都可以进行收发
     pp1,pp2 = multiprocessing.Pipe()

     #启动进程，传递任意一端
     t1=multiprocessing.Process(target=run11,args=(pp1,))
     t1.start()

     #另一端接收数据
     print("得到进程数据：", pp2.recv())
     pp2.send("收到数据了东小东")

进程之数据共享：

两个进程进行数据共享，列表或者字典数据共享

 import multiprocessing

 def run11(vv):
    print("****** 进入进程 ********")

    vv["dong"]="dongxiaodong"
    #vv.append("555") #列表

 # win 进程启动，必须加入这句
 if __name__=="__main__":

     #方法一  -------------：
     # with multiprocessing.Manager() as mssaagex:
     #       dictx=mssaagex.dict() #得到字典参数
     #       #listx=mssaagex.list() #得到列表参数
     #
     #       #启动进程，传递字典或者列表
     #       t1=multiprocessing.Process(target=run11,args=(dictx,))
     #       t1.start()
     #
     #       #等待进程接收
     #       t1.join()
     #
     #       #打印字典数据
     #       print("得到进程数据：", dictx)

      #方法二  -------------------：
      dictx=multiprocessing.Manager().dict() #得到字典参数
      #listx=multiprocessing.Manager().list() #得到列表参数

      #启动进程，传递字典或者列表
      t2=multiprocessing.Process(target=run11,args=(dictx,))
      t2.start()

      #等待进程接收
      t2.join()

      #打印字典数据
      print("得到进程数据：", dictx)

进程锁：

可以保护屏幕打印等，如多个进程同时向屏幕输出数据时，可以保证屏幕数据来自于一个进程，不会出现数据混乱问题

 import multiprocessing

 def run11(vv):
     vv.acquire() #上锁
     print("****** 进入进程 ********")
     vv.release()  #解锁

 # win 进程启动，必须加入这句
 if __name__=="__main__":

      lockx=multiprocessing.Lock() #得到进程锁

      t2=multiprocessing.Process(target=run11,args=(lockx,))
      t2.start()

进程池：

确定进程的同时运行个数，更好的进行进程管理

 import multiprocessing
 import time

 def run11(vv):
     time.sleep(1)
     print("****** 进入进程 ********",vv)

 #回调函数
 #在主进程中运行
 def Cal(arg):
     print("每个进程的回调函数",arg)

 # win 进程启动，必须加入这句
 if __name__=="__main__":

      poolx=multiprocessing.Pool(2) #得到进程池，最多同时执行2个进程

      #启动进程
      for i in range(10):
          #poolx.apply_async(func=run11,args=(i,)) #并行
          poolx.apply_async(func=run11,args=(i,),callback=Cal) #并行并加入执行完毕的回调函数
          #poolx.apply(func=run11,args=(i,)) #串行

      #等待并关闭进程
      poolx.close()
      poolx.join()
      print("-----  完毕  -----")

协程：

单线程实现高并发

安装：pip3 install gevent

手动切换：

import greenlet

def gfunx1():
    print("----gfunx1---")
    g2.switch() #手动切换到 gfunx2 中

def gfunx2():
    print("---gfunx2----")

#声明两个协程
g1=greenlet.greenlet(gfunx1)
g2=greenlet.greenlet(gfunx2)

g1.switch() #手动切换到 gfunx1 中

自动切换：

默认是先运行完gfunx1然后再运行gfunx2,但当遇到IO操作则会自动跳转到另一个协程工作，以此实现在协程中遇到IO就互相切换执行的效果

 import gevent

 def gfunx1():
     print("---- gfunx1 ---")
     gevent.sleep(3) #模拟 IO 操作为 3 秒，但使用time.sleep(x)则会进行阻塞
     print("**** 三秒io操作结束 ******")

 def gfunx2():
     print("---- gfunx2 ----")

 #开启两个协程
 gevent.joinall([
     gevent.spawn(gfunx1),
     gevent.spawn(gfunx2),
 ])

自动切换进阶：

将一系列阻塞操作让协程识别为IO操作

 import gevent
 from gevent import monkey
 #将所有的阻塞操作（如：网络，延时，文件等）都视为gevent可捕获的IO阻塞操作
 #根据库作者提示：此句最好放在其它库import之前，否则会出现警告
 monkey.patch_all()

 import requests
 import time

 def gfunx1():
     print("---- gfunx1 ---")
     res=requests.get("https://img2018.cnblogs.com/blog/1485202/201811/1485202-20181116215233782-319594948.png")
     open("ww.jpg","wb").write(res.content) #以二进制写文件
     print("**** 网络操作结束 ******")

 def gfunx2():
     print("---- gfunx2 ----")
     time.sleep(3) #延时操作也已视为IO阻塞
     print("*** 延时操作结束 3s ***")

 def gfunx3(varx):
     print("---- gfunx3 ----",varx)
     time.sleep(1)
     print("*** 延时操作结束 1s ***")

  #开启三个协程
 gevent.joinall([
     gevent.spawn(gfunx1),
     gevent.spawn(gfunx2),
     gevent.spawn(gfunx3,"") #传递参数
  ])