进程相关内容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())

---