day48-2 Python如何使用多线程

淩亂°似流年 2021-12-14 15:05 179阅读 0赞

*  Python如何使用多进程
    
     *  1.导入multiprocessing中的Process类，并且实例化这个类，指定要执行的任务(如函数)target
     *  2.导入multiprocessing 中的Process类，继承这个类，覆盖run方法，将要执行的任务放入run中，开启进程时则会自动执行该函数
 *  进程之间相互隔离
    
     *  join函数
 *  进程对象的常用属性（了解）
    
     *  僵尸进程与孤儿进程（了解）

## Python如何使用多进程 ##

*  创建子进程的方式

### 1.导入multiprocessing中的Process类，并且实例化这个类，指定要执行的任务(如函数)target ###

import os
    from multiprocessing import Process
    
    # Process就表示进程，在很多地方都是这样
    
    def task():
        print('this is sub process')
        print(f'sub process id {os.getpid()}')
        
    # 注意，开启进程的代码必须放在__main__判断下面，不然会循环导入，下面会详细解释
    if __name__ == '__main__':
        # 实例化一个进程对象
        p = Process(target=task)
        p.start() # 给操作系统发送指令，让它开启进程
        print('this is parent process')
        print(f'parent process is {os.getpid()}')

this is parent process
    parent process is 2060
    this is sub process
    sub process id 10008

#### 为什么要写在main下面 ####

linux 与 windows 开启进程的方式不同

linux 会将父进程的内存数据完整copy一份给子进程

windows 会导入父进程的代码，并且从头执行一遍，来获取需要处理的任务

所以在编写代码时一定要将开启进程的代码放在main判断中，否则就会循环导入

### 2.导入multiprocessing 中的Process类，继承这个类，覆盖run方法，将要执行的任务放入run中，开启进程时则会自动执行该函数 ###

*  在需要对进程对象进行高度自定义时使用

from multiprocessing import Process
    import os
    
    class Downloader(Process):
        
        # def __init__(self, url, size, name):
        #   super().__init__()
        #   self.url = url
        #   self.size = size
        #   self.name = name
        
        def run(self):
            print(os.getpid())
            
    if __name__ == '__main__':
        m = Downloader()
        m.start()   # 这里不要使用run()，因为那样只是运行方法而不是开启进程
        print('parent over', os.getpid())

parent over 1756    # 父进程打印的
    parent over 4048    # 子进程打印的
    4048                # 子进程的run()中打印的

从这个例子的打印顺序中可以得知：**开启子进程需要时间，所以会先执行父进程**

## 进程之间相互隔离 ##

1.可以在开启进程后使用sleep方法，但是这样做并不好，因为你无法确定这个子进程到底会运行多久

### join函数 ###

from multiprocessing import Process
    
    def task1(name):
        for i in range(100):
            print(f'{name} run')
            
    def task2(name):
        for i in range(100):
            print(f'{name} run')
            
    if __name__ == '__main__':     # args 是给子进程传参的，必须是元祖
        p1 = Process(target=task1, args=('p1',))
        p1.start()
        
        p2 = Process(target=task2, args=('p2',))
        p2.start()
        
        p2.join()   # 让主进程，等待子进程执行完毕后再继续执行
        p1.join()
        
        # 达到的效果是，保证两个子进程是并发执行的，并且over一定是在最后打印
        print('over')

案例：

from multiprocessing import Process
    
    def task1(name):
        for i in range(10):
            print(f'{name} run')
            
    if __name__ == '__main__':
        ps=[]   # 需要把每一个进程添加到列表中
        for i in range(10):
            p = Process(target=task1, args=(i,))
            p.start()
            ps.append(p)
            
        for i in ps:    # 遍历列表，保证每一个子进程都已经结束了
            i.join()
            
        # 达到的效果是，把100个打印，分给10个子进程去做，最后打印over   
        print('over')

## 进程对象的常用属性（了解） ##

<table> 
 <thead> 
  <tr> 
   <th style="text-align:center;">方法名</th> 
   <th style="text-align:center;">作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="text-align:center;">p.name</td> 
   <td style="text-align:center;">打印进程名，可以在实例化时添加name参数</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">p.daemon</td> 
   <td style="text-align:center;">守护进程</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">p.exitcode</td> 
   <td style="text-align:center;">获取进程的退出码（就是exit()函数中传入的值）</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">p.is_alive()</td> 
   <td style="text-align:center;">查看进程是否存活</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">p.pid()</td> 
   <td style="text-align:center;">获取进程id（子进程）</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">p.terminate()</td> 
   <td style="text-align:center;">终止进程，与start相同，不会立即终极，操作系统需要时间</td> 
  </tr> 
 </tbody> 
</table>

### 僵尸进程与孤儿进程（了解） ###

孤儿进程 当父进程已经结束，而子进程还在运行，子进程就称为孤儿进程，比如用QQ打开了浏览器，再退掉QQ，那么浏览器就是孤儿进程，这个有其存在的必要性，没有不良影响，孤儿进程会被操作系统所接管

僵尸进程 当一个进程已经结束了，但是它仍然还有一些数据存在，此时称之为僵尸进程

在linux中，有这么一个机制，父进程无论什么时候都可以获取到子进程的一些数据

子进程任务执行完毕后，确实结束了但是仍然保留一些数据，目的是为了让父进程能够获取信息

linux中，可以调用waitpid来彻底释放子进程的残留信息

转载于:https://www.cnblogs.com/lucky75/p/11122980.html