Python代码中进程的简单使用

进程就是正在运行的程序,它是操作系统中资源分配最小的单位,进程号是进程的唯一标识:

• 并发:一个cpu同时不停处理多个程序
• 并行:多个cpu同时不停处理多个程序
• 进程三状态图
  

(1)就绪(Ready)状态
	只剩下CPU需要执行外,其他所有资源都已分配完毕 称为就绪状态。
(2)执行(Running)状态
	cpu开始执行该进程时称为执行状态。
(3)阻塞(Blocked)状态
	由于等待某个事件发生而无法执行时,便是阻塞状态,cpu执行其他进程.例如，等待I/O完成input、
	申请缓冲区不能满足等等。 

Linux中获取进程的命令

ps - aux  #查看进程号
ps - aux | grep  ...   #查找进程
kiil  - 9 ...  #杀死进程

python中相关进程的相关方法

import os
res = os.getpid()
print(res)
# 获取父进程
print(os.getppid())

(1) 进程的基本使用

from multiprocessing import Process
def func():
    print('{}子进程,{}父进程'.format(os.getpid(),od.getppid()))
# 为了解决兼容问题(windows linux)
if __name__ == '__main__':
    p = Process(target = func)
    p.start()

(2)创建带有参数的进程

def func(n):
    for i in range(1,n+1):
        print('{}子进程,{}父进程'.format(os.getpid(),od.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 coount
    count += 1
    print('子进程count={}'.format(count)
if __name__ == '__main__':
    p = Process(target = func)
    p.start()
    print(count)

(4)多个进程之间是异步并发

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

主程序会默认等到所有的子程序执行结束之后,在统一关闭程序,释放资源.
若不等待,有可能在后台存有多个未执行结束的子进程,会变成僵尸进程,不停的占用cpu,内存
增加系统的压力,所有方便于对进程的管理,主进程默认等待子进程.
"""
import time,random
def func(n):
	time.sleep(random.randrange(3))
	print('数字{},子进程{},父进程{}'.format(n,so.getpid(),os.getppid())
if __name__ == '__main__':
	for i in range(1,11):
		Process(target=func,args=(1,)).start()
         print('主进程结束了')
         print(os.getpid())

进程中 join的使用

• 等待所有进程全部执行完毕之后,主进程在执行

#(1) 基本语法
from multiprocessing import Process
import time,os
def func(i):
    print('发送第%s封邮件,要求加薪'%(i)
if __name__ == "__main__":
    lst =[]
    for i in range(10):
          p = Process(target = func,arg=(i,))
          p.start()
          lst.append(p)
    for i in lst:
          i.join()
    print('主进程追后一封邮件')

守护进程

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


默认:主进程会默认等待所有子进程执行结束之后,在关闭程序,释放资源
'''
#(1) 基本语法
from multiprocessing import Process
import time
def func():
    print('开始')
    time.sleep()
    print(;结束)
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.1)
        count += 1
def func2():
    print('开始')
    time.sleep(3)
    print('结束')
if __name__ == "__main__":
    p1 = Process(target=func1)
    p2 = Process(target=func2)
    p1 .daemon -True
    p1.start()
    p2.star()
    print('主进程结束')
#(3) 守护进程实际用途:监控保活
# 守护进行
def alive():
    while True:
        print('报告自己的状态,i am alive')
        time.sleep()
# 执行任务
def func():
    while True:
        try :
            # rasie RuntimeError
            print('我是1号服务器,数据分析中')
        except:
            break
if __name__ = '__main__':
    p1 = Process(target=alive)
    p2 = Process(target=func)
    p1.daemon =True
    p1.strat()
    p2.strat()
    
    p2.join()
    print('当前服务器异常')