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

什么是进程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操做系统结构的基础。

2 进程的两种开启方法
  (1) p = Process(target=None,args(,))
  (2) 自定义类，继承Process父类

3 进程的经常使用方法
  （1） start()  开启一个子进程
  （2） join()   异步变同步（就是让父进程停留在join这句话，等待子进程执行结束，父进程再继续执行）
  （3） is_alive() 判断进程是否活着
  （4） terminate()   杀死进程
4 进程的经常使用属性
   （1） p.name =    给p进程一个名字
   （2） p.pid       返回p进程的pid
   （3） p.daemon = True   将p进程设置为守护进程。（True为守护进程，False为普通进程）

       守护进程的两个特色：
          随着父进程的代码执行完毕才结束
          守护进程不能建立子进程
　　　　　　守护进程必需要在start以前设置

并行:  指二者同时执行，好比有两条车道，在某一个时间点，两条车道上都有车在跑；（资源够用，好比三个线程，四核的CPU ）

并发: 并发是指资源有限的状况下，二者交替轮流使用资源，好比只有一条车道(单核CPU资源)，

　　   那么就是A车先走，在某个时刻A车退出把道路让给B走，B走完继续给A ，交替使用，目的是提升效率。

 

同步: 所谓同步就是一个任务的完成须要依赖另一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，

　　 这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态能够保持一致。

异步: 不须要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工做，依赖的任务也当即执行，

　　 只要本身完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务没法肯定，因此它是不可靠的任务序列。

 

阻塞, 非阻塞:  阻塞和非阻塞这两个概念与程序（线程）等待消息通知(无所谓同步或者异步)时的状态有关。也就是说阻塞与非阻塞主要是程序（线程）等待消息通知时的状态角度来讲的

 

开启子进程的方式:

# 先导入 multiprocessing中的Process
from multiprocessing import Process
import time
import os

def func1():
    time.sleep(1)
    # os.getpid() 获取当前进程的pid,os.getppid()获取当前进程的父进程的pid
    print('子进程:子进程的pid是%s,子进程的父进程是%s' % (os.getpid(),os.getppid()))

if __name__ == '__main__':
    p = Process(target=func1(),args=(1,))
    p.start()
    print('这里是父进程:父进程的pid是%s,父进程的父进程是%s' % (os.getpid(),os.getppid()))

 

进程的经常使用方法:  terminate, is_alive

from multiprocessing import Process
import time

# p.is_alive() 判断进程是否存活  
# p.terminate() 杀死p程序,让解释器告诉操做系统销毁p进程

def func1():
    time.sleep(1)
    print('子进程')


if __name__ == '__main__':
    p = Process(target=func1(),)
    p.start()
    print('子进程状态状态:', p.is_alive())
    p.terminate() # 杀死p进程,让解释器告诉操做系统销毁p进程
    time.sleep(2)
    print('子进程状态状态:',p.is_alive())

 

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

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

 

进程经常使用属性: p.name p.pid p.daemon(守护进程)

 

from multiprocessing import Process
import os

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

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

 

 

多进程之间没法共享内存

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