进程

一. 进程

现代操作系统(windows Mac os x Linux unix ) 都支持多任务

什么叫做多任务:
操作系统同时可以执行多个任务执行
单核系统是怎么实现多任务:

单核cpu实现多任务原理: 操作系统轮流让各个任务交替执行

例如: QQ执行2秒 切换到微信 执行2秒 在切换到微博.....

任务反复执行下去 但是cpu调用太快
导致我们感觉就执行所有任务在同时执行一样

多核系统 实现的原理是在单核之上

并发: 看上去一起执行，任务数多于cpu核心数
并行：真正一起执行 任务数小于等于cpu数

实现多任务的方式：
1. 多进程模式
2. 多线程模式
3.协程模式
4. 多进程+多线程模式

 进程概念

对系统而言每一个程序就是一个进程

进程是系统中程序执行和资源分配的基本单位

每一个进程都有自己的数据段 代码段 和堆栈段

单任务进程

 

from time import sleep

def run():
    while True:
      print("Lover 哈哈哈哈哈哈哈哈")

      sleep(1.2)
    
# 只执行这一个任务   单任务
if __name__== "__main__":

    while True:
      print("girl 啦啦啦啦啦啦啦啦")
      sleep(1)

# 不会执行到run方法
run()

# girl 啦啦啦啦啦啦啦啦
# girl 啦啦啦啦啦啦啦啦
# girl 啦啦啦啦啦啦啦啦
# girl 啦啦啦啦啦啦啦啦

多任务进程

# 多进程
"""multiprocessing 库
是一个跨平台版本多进程模块 提供了一个Process类来代表一个进程对象
"""
from multiprocessing import Process
from time import sleep

def run():
    while True:
      print("Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111")
      sleep(1.2)
    
# 只执行这一个任务   单任务
if __name__== "__main__":

    print("main是主(父)进程启动")

    # 01 创建进程 子进程
    #    target 说明进程执行的指定代码(函数)
    p=Process(target=run)
    #02  启动进程
    p.start()
    while True:
      print("girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000")
      sleep(1)


# irl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 

多任务进程子进程传参

# 多进程
"""multiprocessing 库
是一个跨平台版本多进程模块 提供了一个Process类来代表一个进程对象
"""
from multiprocessing import Process
from time import sleep

# 子进程需要执行代码
def run(str):
    while True:
      print("Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111"+str)

      sleep(1.2)
   
if __name__== "__main__":

    print("main是主(父)进程启动")
    # 01 创建进程 子进程
    #    target 说明进程执行的指定代码(函数)
    p=Process(target=run,args=("my is 张三丰来了",))
    #02  启动进程
    p.start()
    while True:
      print("girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000")
      sleep(1)


//main是主(父)进程启动
# irl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000

多任务进程子进程传参

# 多进程
"""multiprocessing 库

是一个跨平台版本多进程模块 提供了一个Process类来代表一个进程对象
"""
from multiprocessing import Process
from time import sleep
import os

# 子进程需要执行代码
def run(str):
    while True:
      # os.getpid()  获取当前进程的id号
      # os.getppid() 获取当前进程的父进程id号
      print("Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111"+str,os.getpid(),os.getppid()) 
   
if __name__== "__main__":

    print("main是主(父)进程启动",os.getpid())  # 7124


    # 01 创建进程 子进程
    #    target 说明进程执行的指定代码(函数)
    p=Process(target=run,args=("my is 张三丰来了",))
    #02  启动进程
    p.start()


    while True:
      print("girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000")
      sleep(1)

# main是主(父)进程启动 5372
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了 7148 5372
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了 7148 5372
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了 7148 5372
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了 7148 5372
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了 7148 5372
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了 7148 5372
# girl 啦啦啦啦啦啦啦啦000000000000000000000000000000000000000
# Lover 哈哈哈哈哈哈哈哈1111111111111111111111111111111my is 张三丰来了 7148 5372

父子进程先后顺序

# 多进程
"""multiprocessing 库

是一个跨平台版本多进程模块 提供了一个Process类来代表一个进程对象
"""
from multiprocessing import Process
from time import sleep
import os

# 子进程需要执行代码
def run(str):
      print("子进程启动了") 
      sleep(3)
      print("子进程结束")

if __name__== "__main__":

    print("main是主(父)进程启动....")  


    # 01 创建进程 子进程
    #    target 说明进程执行的指定代码(函数)
    p=Process(target=run,args=("nice",))
    #02  启动进程
   
    #父进程的结束不能影响子进程 让父进程等待子进程结束在执行父进程
    p.start()
    print("父进程结束....")
    sleep(1)

# main是主(父)进程启动....
# 父进程结束....
# 子进程启动了
# 子进程结束

父子进程先后顺序

# 多进程
"""multiprocessing 库

是一个跨平台版本多进程模块 提供了一个Process类来代表一个进程对象
"""
from multiprocessing import Process
from time import sleep
import os

# 子进程需要执行代码
def run(str):

      print("子进程启动了") 
      sleep(3)
      print("子进程结束")

if __name__== "__main__":

    print("main是主(父)进程启动....")  


    # 01 创建进程 子进程
    #    target 说明进程执行的指定代码(函数)
    p=Process(target=run,args=("nice",))
    #02  启动进程
   
    #父进程的结束不能影响子进程 让父进程等待子进程结束在执行父进程
    p.start()
    p.join()
    print("父进程结束....")

    sleep(1)

# main是主(父)进程启动....
# 子进程启动了
# 子进程结束
# 父进程结束....

全局变量在多个进程中不能共享

# 多进程
"""multiprocessing 库

是一个跨平台版本多进程模块 提供了一个Process类来代表一个进程对象
"""
from multiprocessing import Process
from time import sleep
import os

num=100

# 说明子进程和父进程用的num是完全不同的   是两个完全不同的变量
# 
def run():

     print("子进程开始")
      
     global num            #global 表示使用全局变量
     num+=1
     print(num)
     print("子进程结束")

if __name__=="__main__":

     print("父进程开始")

     p=Process(target=run)

     p.start()
     p.join()
     print("父进程结束---",num)

# 在子进程中修改全局变量对父进程中的全局变量没有影响
# 在创建子进程时对全局变量做了个备份  
# 在父进程和子进程中的num是两个完全不同的变量

"""
父进程开始
子进程开始
101
子进程结束
父进程结束--- 100"""

全局变量在多个进程中不能共享

# 多进程
"""multiprocessing 库

是一个跨平台版本多进程模块 提供了一个Process类来代表一个进程对象
"""
from multiprocessing import Process
from time import sleep
import os
num=100

# 说明子进程和父进程用的num是完全不同的   是两个完全不同的变量
# 
def run():
     print("子进程开始")
     
     # global num            #global 表示使用全局变量
     num=100  # 相当与 在这里定义一个变量
     num+=1
     print(num)
     print("子进程结束")

if __name__=="__main__":

     print("父进程开始")

     p=Process(target=run)

     p.start()
     p.join()
     print("父进程结束---",num)

# 在子进程中修改全局变量对父进程中的全局变量没有影响
# 在创建子进程时对全局变量做了个备份  
# 在父进程和子进程中的num是两个完全不同的变量

"""注意:
进程是系统中程序执行和资源分配的基本单位

每一个进程都有自己的数据段  代码段  和堆栈段"""

"""
父进程开始
子进程开始
101
子进程结束
父进程结束--- 100"""

启动多个进程

import os,time,random
from multiprocessing import Pool   # 多进程就用Pool  （进程池）


def run(name):

    print("子进程启动22222",name,getpid())

    print("子进程程结束2222",name,getpid())

if __name__ == '__main__':

    print("父进程启动11111")

    # 01 创建多个进程
    #     进程池
    #      表示可以同时执行进程数量
    #      Pool默认大小是cpu核心数
    pp=Pool(2)
    for i in range(5):
        # 02 创建进程 放入进程池统一管理
        pp.apply_async(run,args=(i,))
        
#apply 阻塞       同步方法
# apply_async  阻塞     异步方法

# 注意:在调用join之前必须先调用close 调用close之后就不能再继续添加新的进程了
pp.close()
#注意: 是进程池对象调用join会等待进程池中所有的子进程结束完毕再去执行父进程
pp.join()
print("父进程结束11111")

启动多个进程 (2)

# 多进程
"""multiprocessing 库

是一个跨平台版本多进程模块 提供了一个Process类来代表一个进程对象
"""
from multiprocessing import Pool   #  使用多进程
import os ,time ,random



def run(name):
     print("子进程启动--%s"%(name,os.getpid()))
     # print(name,os.getpid())
     start=time.time()
     time.sleep(random.choiec([1,2,3]))
     end=time.time()
     print("子进程%d结束--%s--耗时%2.f"%(name,os.getpid(),end-start))
     # print(name,os.getpid(),end-start)
     # 
if __name__=="__main__":

  print("父进程启动......................")

   # 01创建多进程
   #    进程池
   # Pool()  默认是大小cpu核心数   
  pp=Pool(2)     #表示可以同时执行的进程数量

  for i in range(3):  # 创建3个进程
        # 创建进程,放入进程池统一管理
        pp.apply_async(run,args=(i,))

   # 在调用join之前必须先调用close调用close之后就不能再继续添加新的进程了
  pp.close()
   # 进程池对象调用join 会等待进程池中所有的子进程结束完毕再去执行父进程
  pp.join()
  print("父进程结束......................")

拷贝文件

import os,time
from multiprocessing import Pool

# 实现文件拷贝
def copyFile(rPath,wPath):
    fr=open(rPath,"rb")
    fw=open(wPath,"wb")
    context=fr.read()
    fw.write(context)
    fr.close()
    fw.close()

path=r"E:\前端资料\ajax的jquery案例\111"

toPath=r"E:\Studypython\线程和进程\多任务管理\1"

# 读取path下所有文件
fileList=os.listdir(path)


start=time.time()

# 处理每一个文件
for fileName in fileList:

  copyFile(os.path.join(path,fileName),os.path.join(toPath,fileName))

end=time.time()
a=end-start

print("总耗时为:",a)

多进程拷贝文件

import os,time
from multiprocessing import Pool

# 实现文件拷贝
def copyFile(rPath,wPath):
    fr=open(rPath,"rb")
    fw=open(wPath,"wb")
    context=fr.read()
    fw.write(context)
    fr.close()
    fw.close()

path=r"E:\1\jquery的ajax实现跨域jsonp"

toPath=r"E:\Studypython\线程和进程\多任务管理\2"

if __name__ == '__main__':
    
  # 读取path下所有文件
    fileList=os.listdir(path)

    start=time.time()
    pp=Pool(2)
    for fileName in fileList:
       pp.apply_async(copyFile,args=(os.path.join(path,fileName),os.path.join(toPath,fileName)))
    pp.close()
    pp.join()
    end=time.time()
    b=end-start
    print(" 总耗时:",b)

进程间的通讯

import os,time
from multiprocessing import Process,Queue

def write(q):
    print("启动写子进程%s"%(os.getpid()))
    for chr in ["A","B","C","D"]:
        q.put(chr)
        time.sleep(1)
    print("结束写子进程%s"%(os.getpid()))

def read(q):
    print("启动读子进程%s"%(os.getpid()))
    while True:
       value=q.get(True)
       print("value="+value)
    print("结束读子进程%s"%(os.getpid()))

if __name__ == '__main__':
   # 父进程创建队列  并传递给子进程
     q=Queue()
     pw=Process(target=write,args=(q,))
     pr=Process(target=read,args=(q,))
     pw.start()
     pr.start()
     pw.join()

     # pr进程里是个死循环 无法等待其结束 只能强行结束
     pr.terminate()
     print("父进程结束")
     
# 启动写子进程3004
# 启动读子进程2612
# value=A
# value=B
# value=C
# value=D
# 结束写子进程3004
# 父进程结束