进程的两种开启方法,进程的常用方法,进程的常用属性

　　进程: 资源分配单位.
　　进程的调度: 多个进程在操作系统控制下被 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)))

进程的两种开启方法,进程的常用方法,进程的常用属性

相关推荐