Python中的进程multiprocessing模块

朴灿烈づ我的快乐病毒、 2022-01-20 12:21 342阅读 0赞

# Python中的进程multiprocessing模块 #

### 文章目录 ###

*  Python中的进程multiprocessing模块
 *   *  Process进程类
     *  进程间同步

由于Python的GIL全局解释器锁存在，多线程未必是CPU密集型程序的好的选择。  
多进程可以完全独立的进程环境中运行程序，可以较充分地利用多处理器。  
但是进程本身的隔离带来的数据不共享也是一个问题。而且线程比进程轻量级。

*  Process类的设计遵循了Thread类的API，减少了学习难度，使用和线程Thread类差不多。
 *  注意：注意：多进程代码一定要放在 `__name__ == "__main__"` 下面执行。
 *  例子，使用多进程解决运行算法密集程序

import multiprocessing
    import datetime
    
    def calc(i):
        sum = 0
        for _ in range(1000000000): #10忆
            sum += 1
        return i,sum
    
    if __name__ == "__main__":
        start = datetime.datetime.now()
        ps = []
        for i in range(4):
            p = multiprocessing.Process(target=calc,args=(i,),name="calc-{}".format(i))
            ps.append(p)
            p.start()
    
        for p in ps:
            p.join()
            # print(p.name,p.exitcode)
    
        print((datetime.datetime.now()-start).total_seconds())
        print("===end===")

![process\_001][process_001]  
上面示例中可以相比之前说到多线程快多了，是真正的并行。

## Process进程类 ##

1.  **构造方法** multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs=\{\}, \*, daemon=None) \#创建一个进程类对象
    
     *  group:只能是None，设计只是为了兼容操作系统。
     *  target:当前进程中的主线程运行的函数
     *  name:进程名称
     *  args:传递给函数的位置参数
     *  kwargs:传递给函数的关键字参数
2.  **Process常用的属性**
    
    <table> 
     <thead> 
      <tr> 
       <th align="left">属性名称</th> 
       <th align="left">含义</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="left">name</td> 
       <td align="left">进程名称</td> 
      </tr> 
      <tr> 
       <td align="left">daemon</td> 
       <td align="left">是否是daemon进程</td> 
      </tr> 
      <tr> 
       <td align="left">pid</td> 
       <td align="left">进程号,进程未启动前该值为None</td> 
      </tr> 
      <tr> 
       <td align="left">exitcode</td> 
       <td align="left">进程的退出状态id。如果进程没有终止，返回None</td> 
      </tr> 
      <tr> 
       <td align="left">anthkey</td> 
       <td align="left">进程身份密钥，进程初始化时会使用 os.urandom()为进程随机生成一个二进制字符串</td> 
      </tr> 
     </tbody> 
    </table>
3.  **Process常用方法**

<table> 
 <thead> 
  <tr> 
   <th align="left">常用方法</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">start(self)</td> 
   <td align="left">启动进程</td> 
  </tr> 
  <tr> 
   <td align="left">run(self)</td> 
   <td align="left">进程运行函数</td> 
  </tr> 
  <tr> 
   <td align="left">join([timeout=None])</td> 
   <td align="left">会产生一个阻塞，直到进程执行完成退出后返回True,<br>timeout超时时长。指定时长内未结束会返回False</td> 
  </tr> 
  <tr> 
   <td align="left">is_alive()</td> 
   <td align="left">是否是活动进程，进程是否活着</td> 
  </tr> 
  <tr> 
   <td align="left">terminate()</td> 
   <td align="left">终止进程，注意终止进程，进程会立即退出，退出处理程序和finally子句等将不会执行。</td> 
  </tr> 
  <tr> 
   <td align="left">kill()</td> 
   <td align="left">终止进程，和terminate类似，通常是在Unix系统上使用</td> 
  </tr> 
  <tr> 
   <td align="left">close()</td> 
   <td align="left">关闭进程流对象，释放资源，必须在join()活着terminate()方法后使用。即必须等进程运行完成后使用。<br>注意：关闭进程流对象后，进程id，状态等信息将无法使用，否则会报ValueError异常，但进程名称可以访问。</td> 
  </tr> 
 </tbody> 
</table>

import multiprocessing
    import threading
    
    def calc(i):
        try:
            sum = 0
            for _ in range(10000000): #10忆
                sum += 1
            return i,sum
        finally:
            print("我退出了")
    
    if __name__ == "__main__":
        process = multiprocessing.Process(target=calc,args=(1,),name="pro-1")
        process.start()
        print(process.name)
        print(process.daemon)
        print(process.ident)
        print(process.pid)
        # print(process.terminate())
        # process.kill()
        process.join()
    
        print(process.exitcode)  # 进程退出的状态码
        print(process.authkey)
        process.close()
        print(process.pid)

![process\_002][process_002]

## 进程间同步 ##

Python在进程间同步提供了和线程同步一样的类，使用方法一样，使用的效果也类似，不过进程间代价要高于线程间，而且系统底层实现是不通的。只不过Python屏蔽了这些不通之处，让用户简单使用多进程。

multiprocessing提供的同步类有：  
\* multiprocessing.Event  
\* multiprocessing.RLock  
\* multiprocessing.Lock  
\* multiprocessing.Condition  
\* multiprocessing.Semaphore  
\* multiprocessing.BoundedSemaphore  
\* mulitiprocessing.Queue \#队列，多进程中使用的队列，先进先出  
具体使用方法请参见线程中对应类的使用[线程同步与线程锁][Link 1]

multiprocessing还提供共享内存、服务器进程来共享数据，还提供了用于进程间通讯的Queue队列、Pipe管道。  
通信方式不同  
1. 多进程就是启动多个解释器进程，进程间通信必须序列化、反序列化  
2. 数据的线程安全性问题(如果每个进程中没有实现多线程，GIL可以说没什么用了)

[process_001]: https://raw.githubusercontent.com/1263351411/xdd.github.io/master/img/python/process_001.jpg
[process_002]: /images/20220120/8502dc836ba540069831ced8d8902023.png
[Link 1]: https://blog.csdn.net/u013008795/article/details/91357383