进程: 资源分配单位.
进程的调度: 多个进程在操作系统控制下被 cpu执行, 去享用计算机资源.
先来先服务 算法
短作业优先 算法
时间片轮转 算法
多级反馈队列(包含上面三个的东西)
进程调度的过程是不能够随意被程序影响的. ps: 此时可以更改代码去配合 操作系统,
程序的并行与并发:
并行: 更快
并发: 宏观上同时执行
进程一共有三个状态: 就绪, 运行, 阻塞
同步, 异步 ps: 从宏观角度来看.
堵塞, 非堵塞
PID: Process ID 进程ID
ppid: parent process id 父进程id
父进程: 负责回收一些子进程的资源.
Python来完成多进程: multiproess 包
创建进程: multiprocessing.Process 模块
1, start() :不是运行一个程序, 而是调用操作系统的命令, 要开启创建的子进程.
在不同的操作系统 使用Python, 都是调用操作系统的命令来启动进程的, 且不同的操作系统操作Python都是不同的.
在windows 操作系统开启了一个子进程, 第一步相当于import了父进程所在的文件.所以, 开启子进程的时候, 必须把 创建子进程对象和start() 写在
if __name__ == '__main__' 下面.
在 linux和ios来说, 是完全复制所有的变量一份放到子进程里面, 所以 不用加 if __name__ == '__main__'
2 进程的两种开启方法
(1) p = Process(target=None,args(,))
from multiprocessing import Process
import time
import os
def func(i):
time.sleep(1)
print('这里是儿子进程,儿子自己的pid是%s,儿子的父进程的pid是%s'%(os.getpid(),os.getppid()))
# os.getpid()获取的是当前进程自己的pid
# os.getppid()获取的是当前进程的父进程的pid
if __name__ == '__main__':
p = Process(target=func,args=(1,))# 实例化一个进程对象
p.start()# 开启一个子进程
print('这里是父亲进程，父进程自己的pid是：%s,父亲的父亲的pid是%s'%(os.getpid(),os.getppid()))
(2) 自定义类，继承Process父类
from multiprocessing import Process
import time
import os
class MyProcess(Process):
def __init__(self):
super(MyProcess, self).__init__()
def run(self):
print('这是以继承类的方式开启的子进程')
if __name__ == '__main__':
p1 = MyProcess()
p1.start()# 是指，解释器告诉操作系统，去帮我开启一个进程， 就绪状态
# p1.run()# 告诉操作系统，现在马上帮我执行这个子进程 执行
class MyProcess(Process):
def __init__(self):
super(MyProcess, self).__init__()# 执行父类的__init__方法
# self.name = name
def run(self):
print('这是以继承类的方式开启的子进程,他的名字是%s'%self.name)
if __name__ == '__main__':
p1 = MyProcess()
p1.start()# 是指，解释器告诉操作系统，去帮我开启一个进程， 就绪状态
p1.run()# 告诉操作系统，现在马上帮我执行这个子进程 执行
3 进程的常用方法
（1） start() 开启一个子进程
（2） join() 异步变同步（就是让父进程停留在join这句话，等待子进程执行结束，父进程再继续执行）
from multiprocessing import Process
import time
def func():
for i in range(500):
time.sleep(0.01)
print('儿子')
if __name__ == '__main__':
p=Process(target=func)
p.start()
p.join()# 是让主进程等待子进程执行完。 现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
for i in range(100):
time.sleep(0.01)
print('爸爸')
开启一个正常的子进程，父进程会等待子进程结束后，父进程也就是程序才结束
p.join()# 是让主进程等待子进程执行完。 现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
如何把父进程和子进程之间的关系变为同步或者异步？
父进程执行join，就会变成同步，不执行join，父进程和子进程就是异步的关系
join必须放在start()后边
（3） is_alive() 判断进程是否活着
（4） terminate() 杀死进程
from multiprocessing import Process
import time
def func():
time.sleep(1)
print(123)
if __name__ == '__main__':
p=Process(target=func,)
p.start()
p.terminate()# 杀死p进程,让解释器告诉操作系统，请杀掉p进程。
time.sleep(0.0002)
print('子进程是否还活着？', p.is_alive())
time.sleep(0.2)
print('子进程是否还活着？', p.is_alive())# 返回一个bool值，如果返回True，代表进程还活着,
# 如果返回False，代表子进程死了
# p.is_alive() 判断p进程是否还活着
# p.terminate() 杀死p进程
4 进程的常用属性
（1） p.name = 给p进程一个名字
（2） p.pid 返回p进程的pid
（3） p.daemon = True 将p进程设置为守护进程。（True为守护进程，False为普通进程）
守护进程的两个特点：
守护进程会随着父进程的结束而结束
守护进程不能再创建子进程（不能要孩子）
守护进程:
from multiprocessing import Process
import time
def func():
time.sleep(100)
print('这里是儿子哦')
if __name__ == '__main__':
p = Process(target=func)
p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
p.start()
time.sleep(1)
print('这是爸爸')
###### 守护进程：跟随着父进程的代码执行结束，守护进程就结束
from multiprocessing import Process
import time
def func1():
print('孙子')
def func():
p = Process(target=func1)
p.start()
time.sleep(3)
print('儿子')
if __name__ == '__main__':
p=Process(target=func)
p.daemon = True
p.start()
time.sleep(1)
print('爸爸')
####守护进程：不允许开启子进程
from multiprocessing import Process
import time
def func():
for i in range(100):
time.sleep(1)
print(time.strftime('%Y:%m:%d'))
print(time.strftime('%H:%M:%S'))
if __name__ == '__main__':
p = Process(target=func)
p.daemon = True
p.start()
time.sleep(5)
print('爸爸')
#######将p进程设置为守护进程,必须要在start之前设置
5,如何开启多个不同的子进程
from multiprocessing import Process
import time
import os
def func(i):
time.sleep(1)
print('这里是儿子%s进程,儿子自己的pid是%s,儿子的父进程的pid是%s'%(i,os.getpid(),os.getppid()))
if __name__ == '__main__':
for i in range(2):
p = Process(target=func,args=(i,))
p.start()
print('这里是父亲进程，父进程自己的pid是：%s,父亲的父亲的pid是%s'%(os.getpid(),os.getppid()))
# os.getpid()获取的是当前进程自己的pid
# os.getppid()获取的是当前进程的父进程的pid
# p = Process(target=func,args=(i,))# 实例化一个进程对象
# p.start()# 开启一个子进程
多个子进程:
from multiprocessing import Process
import time
import random
def func(i):
print('我是%s'%i)
if __name__ == '__main__':
l=[]
addr = ['河南的','湖南的','海南的']
for i in addr:
p=Process(target=func,args=(i,))
p.start()
# p.join()
l.append(p)
[p.join() for i in l]
time.sleep(0.1)
print('我选%s'%(random.choice(addr)))