ptthon课程day35-进程,多进程,多个子进程

 

1如何开启多进程及多进程相关常用方法

 

   并行 ： 两个进程在同一时间点发生
    并发 ： 两个进程在同一时间间隔内运行

        早期单核cpu时候，没有并行的概念，只有并发（微观上串行，宏观上并行）

     

    同步 ： 某一个任务的执行必须依赖于另一个任务的返回结果
    异步 ： 某一个任务的执行，不需要依赖于另一个任务的返回，只需要告诉另一个任务一声
    阻塞 ： 程序因为类似于IO等待、等待事件等导致无法继续执行。
    非阻塞：程序遇到类似于IO操作时，不再阻塞等待，如果没有及时的处理IO，就报错或者跳过等其他操作

      from multiprocessing import Process

      获取当前进程的pid号，os.getpid()

      获取当前进程的父进程的pid号，os.getppid()

      开启子进程的方式：

         1 p = Process(target=func,args=(,))

           target: 是子进程要执行的任务

           args：是父进程给子进程传递的参数

         2 自定义类，去继承Process

      进程的方法：

          p.start()开启子进程，底层调用的是p.run()

进程的方法和属性：
    方法：start（）  开启一个子进程
          join       异步变同步，让父进程等待子进程的执行结束，再继续执行
          is_alive， 判断进程是否活着
          terminate  杀死进程
    属性：
          name   子进程的名字
          pid    子进程的pid
          daemon  设置进程为守护进程，给一个True代表为守护进程，默认为False，不是守护进程
守护进程
    特点：
        随着父进程的代码执行完毕才结束
        守护进程不能创建子进程
        守护进程必须要在start之前设置

 

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()# 是让主进程等待子进程执行完。  现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
    # time.sleep(1)
    for i in range(100):
        time.sleep(0.01)
        print('爸爸在这里')

# 开启一个正常的子进程，父进程会等待子进程结束后，父进程也就是程序才结束
# p.join()# 是让主进程等待子进程执行完。  现象：主进程执行到这句话，主进程阻塞住，等待子进程执行
# 如何把父进程和子进程之间的关系变为同步或者异步？
# 父进程执行join，就会变成同步，不执行join，父进程和子进程就是异步的关系
# join必须放在start()后边

from multiprocessing import Process
import time
import os

def func():
    print('这里是儿子,儿子的pid是%s'%(os.getpid()))

if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.name = 'alex'
    print('儿子的名字是%s'%p.name)
    print('儿子的pid是%s'%p.pid)
    print('儿子是不是守护进程？',p.daemon)

# 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(5)
#     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 func():
    for i in range(10):
        time.sleep(1)
        print(time.strftime('%H:%M:%S'))

if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True # 将p进程设置为守护进程,必须要在start之前设置
    p.start()
    time.sleep(5)
    print('这是爸爸')

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()))

######################################### 开启子进程的另外一种方式，以继承的方式

# 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()# 告诉操作系统，现在马上帮我执行这个子进程           执行


#################################################如何开启多个不同的子进程

# def func(i):
#     time.sleep(1)
#     print('这里是儿子%s进程,儿子自己的pid是%s,儿子的父进程的pid是%s'%(i,os.getpid(),os.getppid()))
#
# # os.getpid()获取的是当前进程自己的pid
# # os.getppid()获取的是当前进程的父进程的pid
# 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()))

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进程。
    print('子进程是否还活着？', p.is_alive())
    time.sleep(0.002)
    print('子进程是否还活着？', p.is_alive())
    # 返回一个bool值，如果返回True，代表进程还活着,如果返回False，代表子进程死了

# p.is_alive() 判断p进程是否还活着
# p.terminate() 杀死p进程

 

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 p in l]
#     time.sleep(1)
#     print('我选%s'%(random.choice(addr)))

from multiprocessing import Process
def func(i):
    print('我是%s'%i)
    # global n
    # print(n)


if __name__ == '__main__':
    n = 100
    addr = ['河南的','山东的','辽宁的','湖南的']
    for i in addr:
        p = Process(target=func,args=(i,))
        p.start()