进程相关内容01
一.进程的两种开启方法:
1, p = Process(target = None, args = (变量,))
2, 自定义类, 继承Process父类
注意: 在开启进程之前, 要先导入multiprocessing 模块中的 Process 方法
multiprocessing import Process
二.进程中的常用方法,操作:
- 1, p = Process(target = func, args = (参数,)) 实例化一个进程
- 2, start() 开启一个子进程
- 3, join() 异步变同步(就是让父进程停留在join这句话, 等待子进程执行完之后继续执行父进程)
- 4, terminate() 杀死进程.
三.进程的常用属性:
- 1, p.name = 给p进程一个名字
- 2, p.pid 返回p进程的pid
- 3, daemon = Ture 将p进程设置为守护进程. (Ture为守护进程, False为普通进程.)
- 守护进程的两个特点:
- 1, 守护进程会随着父进程的结束而结束.
- 2, 守护进程不能再创建子进程.
- 注意: 多进程变成中数据不安全.所以要使用锁机制.
初识进程:
# 开启多继承01
# import time
# from multiprocessing import Process
# def f(name):
# print('hello', name)
# print('我是子进程')
# if __name__ == '__main__': # 在pycharm中, 运行多进程时是必须要写的
# p = Process(target=f, args=('bob',))
# # 实例化一个进程对象
# # args里的内容, 就是上面f 函数里要传入的参数.参数只能一一对应.
# # 或者设置参数的时候设置为关键字参数也可.
# p.start() # 开启子进程
# time.sleep(1) # 睡眠1秒
# print('执行主进程的内容了')
# ====================进程02
# from multiprocessing import Process
# import time
#
# def f(i):
# time.sleep(1)
# print('第%d执行了子进程'% i)
# if __name__ == '__main__':
# for i in range(5):
# p = Process(target=f, args=(i,)) # 实例化一个进程
# p.start() # 开启一个子进程
# print('执行了父进程')
# 在循环中, args 的参数可以是循环中的i.
# =========类方法进程
# from multiprocessing import Process
# import time
# class MyProcess(Process):
# def __init__(self, name):
# self.name = name
# super(MyProcess, self).__init__(name=self.name)
# # 此时是执行父类的__init__方法,如果不传参数默认使用底层的name= ''
# # 会覆盖掉之前传入的name,这里给name限定了名字,所以不会被覆盖,
# # 或者不传参数的话, 将self.name = name 放在super()后面去执行.
# def run(self):
# print('这是可以继承类方法开启的子进程%s' %self.name)
# if __name__ == '__main__':
# p = MyProcess('alex') # 实例化一个进程
# p.start() # 开启一个子进程
# os.getpid() 获得进程的pid
# os.getppid() 获得父进程的pid
join()方法使用:(讲一个子进程变成父进程的守护进程.)
守护进程会随着父进程的结束而结束
守护进程不能再# 在一个正常的子进程中, 父进程要等待子进程结束后,父进程(也就是程序)才会结
# from multiprocessing import Process # import time # # def f(i): # time.sleep(3) # 睡眠三秒 之后在运行下面的程序 # print('第%d执行了子进程'% i) # # if __name__ == '__main__': # # for i in range(5): # p = Process(target=f, args=(1,)) # 实例化一个进程 # p.start() # 运行一个子进程 # time.sleep(2) # 父进程睡眠2秒, 作用: 等待子进程运行 # print('执行了父进程')
#调用join以后 # from multiprocessing import Process # import time # # def f(i): # for i in range(10): # time.sleep(0.1) # print('第%d执行了子进程' %(i + 1)) # # if __name__ == '__main__': # p = Process(target=f, args=(1,)) # p.start() # p.join()
# # 让父进程等待子进程执行完以后再继续执行(父进程阻塞住, 等待子进程执行完毕) # # 调用join以后, 只有先执行完子进程以后才能继续执行父进程 # # 可以理解为将异步,转变成同步 # for i in range(10): # time.sleep(0.1) # print('第%d执行了父进程' %(i + 1))
# 调用join以后, 父进程需要等待子进程执行完以后才能继续执行父进程. # 如何将父进程和子进程之间的关系变为同步和异步? # 父进程执行join, 就会变成同步, 不执行join 就会变成异步.
守护进程补充: # ============== 守护进程的用法 # # 守护进程: 跟着父进程的代码的结束, 也跟着结束 # # 守护进程: 自己不能再开启子进程 # # p.daemon = True # 将P进程设置为守护进程, 必须在start之前设置 # from multiprocessing import Process # import time # # def func(): # for i in range(30): # time.sleep(0.5) # print('这是子进程') # # if __name__ == '__main__': # p = Process(target=func) # p.daemon = True # 将p进程设置为守护进程, 必须在运行子进程(p.start())之前设置. # p.start() # time.sleep(2) # print('这是父进程') # 将p设置为守护进程后, 当主进程结束后, 不管守护进程后面时候还有内容没打印守护进程也跟着结束, # 多个金正之间是无法共享内存的(因为每个进程之间都有自己独立的内存空间) # 多进程在执行的时候, # from multiprocessing import Process # # def func(i): # global n # # 此处获取父进程中的全局变量是获取不到的. # # 在多进程中, 无法共享同一个数据(哪怕是全局变量), 无法共享内存. # print(n) # # if __name__ == '__main__': # n = '哈哈哈' # addr = ['脸大的', '头铁的', '腿短的', '脖子短的'] # for i in addr: # p = Process(target=func, args=(i,)) # # 在多进程中,相当于把每个子进程拷贝一份出去单独运行 # # 在原空间中不再执行子进程. # p.start()
p.is_alive() ===> 判断p进程是否活着.
p.terminate() # 杀死p进程, (解释器告诉操作系统, 让系统去杀死进程)
# 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进程, (解释器告诉操作系统, 让系统去杀死进程) # print('子进程时候还活着?', p.is_alive()) # time.sleep(0.02) # # 解释器有延时, 睡眠一段时间, 等待解释器去反应, 再次进行判断子进程是否存货 # print('子进程时候还活着?', p.is_alive())
