python进程概要

Posted 2022-03-11 thotf

进程

狭义：正在运行的程序实例。

广义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动，他是操作系统动态执行的基本单元。

python的进程都是并行的。

并行：两个进程同时执行一起走。

并发：逻辑上是两个线程同时进行，物理上是交替执行。

 

 1 import multiprocessing
 2 
 3 def fun1(i):
 4     print(multiprocessing.current_process(),i)
 5 
 6 if __name__ == "__main__":
 7     mp_lst = []
 8     for i in range(100):
 9         m = multiprocessing.Process(target=fun1,args=(i,))
10         m.start()
11         mp_lst.append(m)
12 
13     _ = [i.join() for i in mp_lst]

简单开启100个进程

python进程和线程的使用方式没啥区别

start() 开启进程

join() 等待，直到进程完成其工作并退出位置

为什么要使用__name__ == "__mian__"呢？

因为进程再创建时要导入目标函数的脚本，使用__name__ == "__mian__"方式来防止无限递归。

如果目标函数不在和开启进程同一个脚本中就不需要使用。

class Process():

    # TODO: set type of group to None
    def __init__(self,
                 group: Any = ...,
                 target: Optional[Callable] = ..., #函数
                 name: Optional[str] = ...,  #进程名
                 args: Iterable[Any] = ...,  #参数
                 kwargs: Mapping[Any, Any] = ...,
                 *,
                 daemon: Optional[bool] = ...)  #是否在后台运行进程 
    def start(self)    #开启进程

    def run(self)      #目标函数

使用类开启多个进程

 

如何在后台运行进程

python没有守护进程，没有守护进程，没有守护进程 说三遍。

后台进程是一种典型的耗时执行模式，他不需要人为干预，但是可以与其他程序并发，python通过设置daemon选项设置后台进程。

后台进程不能有子进程，因为后台进程的父进程退出时它会终止，如果有子进程那么子进程就会变成游离状态。

 1 import multiprocessing
 2 
 3 class MyProcess(multiprocessing.Process):
 4     def __init__(self):
 5         super(MyProcess, self).__init__()
 6 
 7 
 8     def run(self):
 9         print(self.name)
10 
11 
12 a = MyProcess()
13 a.daemon = True #设置后台进程
14 a.start()

后台进程简单应用

 

杀死进程

 1 class MyProcess(multiprocessing.Process):
 2     def __init__(self):
 3         super(MyProcess, self).__init__()
 4 
 5 
 6     def run(self):
 7         print(self.name)
 8 
 9 
10 a = MyProcess()
11 
12 a.start()
13 
14 a.terminate() #杀死进程
15 time.sleep(5)
16 print(a.is_alive()) #判断进程存活
17 a.join()

杀死进程示例

进程不会被立刻杀死，需要一定时间。

p.exitcode 状态码

==0：表示没有错误

>0:表示进程遇到了错误并退出。

<0:表示进程被信号杀死了。

进程锁与递归锁同线程

信号量、事件都和线程一样

进程同步

python 3.2新增特性屏障barrier 

import multiprocessing
from multiprocessing import Process,Barrier,Lock
import time

def fun1(br,lockto):
    br.wait()  #屏障阻塞
    now = time.time()
    with lockto:   #利用with获取和释放锁
        print(multiprocessing.current_process().name,now)

def fun2():
    now = time.time()
    print(multiprocessing.current_process().name,now)


if __name__ == "__main__":
    br = Barrier(2)  #设置屏障要阻塞几个进程
    lockto = Lock()
    p1 = Process(target=fun1, args=(br, lockto), name="p1_prosess")
    p2 = Process(target=fun1, args=(br, lockto), name="p2_prosess")
    p3 = Process(target=fun2, name="p3_prosess")
    p4 = Process(target=fun2, name="p4_prosess")
    p1.start()
    p2.start()
    p3.start()
    p4.start()
    p1.join()
    p2.join()
    p3.join()
    p4.join()


输出：
p3_prosess 1562118519.9697998
p2_prosess 1562118519.9697998
p1_prosess 1562118519.9697998
p4_prosess 1562118519.9768193

我们可以看到p1和p2的时间是完全相同的至于p3为什么也相同=。=俺电脑太棒了只能说，多测试几遍就有不同的值了不贴了。

这个屏障的作用就是wait阻塞住以后按照前面设置的阻塞进程的数量来拦截进程，我这里设置的是2个所以就第一个进程到达时阻塞直到第二个进程到达才一起释放。如下图：

 

利用进程管理器进行数据共享

 1 import multiprocessing
 2 
 3 def fun1(mg_dict,x,y):
 4     mg_dict[x] = y
 5     
 6 if __name__ == "__main__":
 7     mg = multiprocessing.Manager()  #生成管理器对象
 8     mg_dict = mg.dict()  #创建共享字典
 9 
10     p_lst = [multiprocessing.11                  Process(target=fun1,args=(mg_dict,i,i*2)) for i in range(10)]
12 
13     [p.start()for p in p_lst]
14     [task.join()for task in p_lst]
15 
16     print(mg_dict)

利用管理器共享数据

如果要访问数据也要加锁奥~