python进程

1、概念

进程是一个执行中的程序，资源分配的最小单位。每个进程都拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据。在单核CPU系统中的多进程，内存中可以有许多程序，但在给定一个时刻只有一个程序在运行；就是说，可能这一秒在运行进程A，下一秒在运行进程B，虽然两者都在内存中，都没有真正同时运行。

2、常用方法

ps -aux 查看进程号
ps -aux | grep 2860
kill -9 2860  杀死进程

# 获取当前进程id (子进程)
res = os.getpid()
print(res)

# 获取当前进程的父进程
res2 = os.getppid()
print(res2)

3、进程的基本使用

from multiprocessing import Process
# (1) 进程的基本使用
def func():
    print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid()))

# 为了解决windows 和 linux 系统的兼容问题,下面这句话必须加上,否则报错
if __name__ == "__main__":
    # 创建子进程,返回进程对象,执行func这个任务
    p = Process(target=func)
    # 调用子进程
    p.start()
# (2) 创建带有参数的进程
def func(n):
    for i in range(1,n+1):
        print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid()))

if __name__ == "__main__":
    n = 5
    #创建子进程
    p = Process(target=func,args=(n,))
    #调用子进程
    p.start()

    for i in range(1,n+1):        
        print("*" * i)
# (3) 进程之间的数据彼此隔离
count = 10
def func():
    global count
    count += 1
    print("我是子进程count={}".format(count))

if __name__ == "__main__":
    p=Process(target=func)
    p.start()
    time.sleep(1)
    print(count)

4、其他信息

多个进程之间是异步并发的程序,因为cpu的调度策略问题,不一定哪个任务先执行,哪个任务后执行.
整体而言,主进程比子进程创建的速度要快,cpu遇到阻塞会立刻切换任务,等到阻塞态的任务变成了就绪态,cpu再回来执行

主程序会默认等到所有的子程序执行结束之后,在统一关闭程序,释放资源.
若不等待,有可能在后台存有多个未执行结束的子进程,会变成僵尸进程,不停的占用cpu,内存
增加系统的压力,所有方便于对进程的管理,主进程默认等待子进程.

5、join 等待当前子进程全部执行完毕之后,主进程在执行(用来同步子父进程的)

from multiprocessing import Process
import time,os
# (1) join 基本语法
def func():
    print("发送第一封邮箱,要求张工资")
    
if __name__ == "__main__":
    p = Process(target=func)
    p.start()
    
    # 必须等待子进程全部执行结束之后,在执行主进程中的代码,用join来同步子父进程.
    p.join()
    # time.sleep(1)
    print("发送第二封邮箱,涨到一个月6万")
    
# (2) 多个子进程的场景中使用join
def func(i):
    time.sleep(1)
    print("发送第%s封邮箱,要求升职加薪" % (i))
    
if __name__ == "__main__":
    lst = []
    for i in range(10):
        p = Process(target=func,args=(i,))
        p.start()
        lst.append(p)

    for i in lst:
        i.join()
        
    print("主进程发最后一封邮件:此致敬礼~")

6、使用自定义类方法创建进程

自定义进程类的要求:
(1) 必须继承Process这个父类
(2) 所有进程执行任务的逻辑必须写在run方法里面

# 1.基本语法
class MyProcess(Process):
    def run(self):    
        print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid()))
        
if __name__ == "__main__":
    p = MyProcess()
    p.start()
    print("3.子进程id>>{},4父进程id>>{}".format(os.getpid(),os.getppid()))
    

# 2.带有参数自定类的方法
class MyProcess(Process):
    def __init__(self,arg):
        # 手动调用一下父类的构造方法(最终实现进程的创建)
        super().__init__()
        self.arg = arg

    def run(self):    
        print("1.子进程id>>{},2父进程id>>{}".format(os.getpid(),os.getppid()))
        print(self.arg)
    
if __name__ == "__main__":
    p = MyProcess("我是传进来的参数")
    p.start()
    print("3.子进程id>>{},4父进程id>>{}".format(os.getpid(),os.getppid()))

7、守护进程

# ### 守护进程
"""
守护进程守护的是主进程,如果主进程中的所有代码执行完毕了,
当前这个守护进程会被立刻杀死,立刻终止.
语法:
进程.daemon = True 设置当前这个进程为守护进程
必须写在start()调用进程之前进行设置


默认:主进程会默认等待所有子进程执行结束之后,在关闭程序,释放资源
"""
from multiprocessing import Process
import time
# (1) 基本使用
"""
def func():
    print("start当前子进程")
    time.sleep(1)
    print("end当前子进程")
if __name__ == "__main__":
    p = Process(target = func)
    p.daemon = True
    p.start()
    
    print("主进程执行结束 ... ")
"""

# (2) 多个子进程的场景
"""
def func1():
    count = 1
    while True:
        print("*" * count)
        time.sleep(0.5)
        count += 1
        
def func2():
    print("start func2 当前子进程任务")
    time.sleep(3)
    print("end   func2 当前子进程任务")

if __name__ == "__main__":
    p1 = Process(target=func1)
    p2 = Process(target=func2)
    
    # 设置p1这个进程对象为守护进程
    p1.daemon = True
    
    p1.start()
    p2.start()
    
    time.sleep(1)
    
    print("主进程执行结束 ... ")
"""
# (3) 守护进程实际用途: 监控报活
# 守护进行
def alive():
    while True:
        print("给监控的总服务器发消息,报告自己的存活状态, i am alive~")
        time.sleep(1)        

# 执行任务
def func():
    while True:        
        try:
            time.sleep(1)
            raise RuntimeError
            print("当前5号服务器功能:对日志进行数据分析.... ")
        except:
            break
            # pass

if __name__ == "__main__":
    # 创建2个子进程
    p1 = Process(target=alive)
    p2 = Process(target=func)
    # 设置p1为守护进程
    p1.daemon = True
    
    p1.start()
    p2.start()
    
    # 必须等到p2任务执行结束之后,在向下执行.
    p2.join()
    
    print("当前服务器状态异常 ... ")

 8、进程锁　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

创建进程的时候,仍然是异步并发,
在执行到上锁时,多个进程之间变成了同步程序.
先来的先上锁,先执行,后来的进程后上锁,后执行

# ### 锁 lock
from multiprocessing import Process,Lock
# (1) lock基本用法
"""
上锁和解锁是一对,只上锁不解锁会发生死锁现象(代码阻塞,不往下执行了)
互斥锁 : 互斥锁是进程之间的互相排斥,谁先抢到这个锁资源就先使用,后抢到后使用
"""


# 创建一把锁
lock = Lock()
# 上锁
lock.acquire()
# 连续上锁不解锁是死锁
# lock.acquire() error

print("厕所中...")

# 解锁
lock.release()
print("执行程序 ... ")