多任务原理,线程,进程

一. 现代操作系统(Windows,Mac OS X, Linux, Unix等)都支持”多任务”

• 什么叫多任务?
  操作系统同时可以运行多个任务

• 什么是进程呢?
  对于操作系统而言,一个任务就是一个进程, 进程是系统中程序执行和资源分配的基本单位.每个进程都有自己的数据段,代码段和堆栈段

• 单核CPU实现多任务原理:操作系统轮流让各个任务交替执行,QQ执行2us,切换到微信执行2us,以此类推.表面是看每个任务反复执行下去,但是CPU调度执行速度太快了,导致我们感觉就像所有任务都在同时执行一样

• 多核CPU实现多任务原理:真正的执行多任务只能在多核CPU上实现,但是由于任务数量远远多于CPU的核心数量,所以,操作系统也会自动把很多任务轮流调度到每个核心上执行

• 并发:看上去一起执行,任务数多于CPU核心数
  并行:真正一起执行,任务数小于等于CPU核心数

• 实现多任务的方式:
  – 多进程模式
  – 多线程模式
  – 协程模式
  – 多进程+多线程模式

二. 单任务现象

from time import sleep


def run():
    while True:
        print("sunck is a nice man")
        sleep(1.2)


if __name__ == "__main__":
    while True:
        print("sunck is a good man")
        sleep(1)

    #不会执行到run方法,只有上面的while循环结束才可以执行, 这就是单个进程的局限性, 从上往下必须挨着顺序执行,碰到死循环就嗝屁了, 下面的代码就不会再执行了!!!
    run()

三. 启动进程实现多任务

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


def run(str):
    while True:
        #os.getpid()获取当前进程id号
        #os.getppid()获取当前进程的父进程id号
        print("sunck is a %s man--%s--%s"%(str,'当前进程号:%s' % os.getpid(), '父进程号:%s' % os.getppid()))
        sleep(5)

if __name__ == "__main__":
    print("主/父进程启动--%s"%(os.getpid()))
    #创建子进程
    #target说明进程执行的任务
    p = Process(target=run, args=["handsome"])   # 创建子进程, 执行函数run, 传入参数handsome, 注意元组里面只有一个元素的时候必须加逗号
    #启动进程
    p.start()
    while True:
        print("sunck is a good man")
        sleep(5)

执行结果:

主/父进程启动--11536
sunck is a good man
sunck is a handsome man--当前进程号:11676--父进程号:11536
sunck is a good man
sunck is a handsome man--当前进程号:11676--父进程号:11536

四. 进程间的先后顺序

from multiprocessing import Process
from time import sleep
def run(str):
    print("子进程启动")
    sleep(3)
    print("子进程结束")
if __name__ == "__main__":
    print("父进程启动")
    p = Process(target=run, args=("handsome",))
    p.start()
    #父进程的结束不能影响子进程,让父进程等待子进程结束,再执行父进程
    p.join()        # 让父进程阻塞在这里, 等待子进程结束后再执行以下语句

    print("父进程结束")

五. 全局变量在进程间不能共享

from multiprocessing import Process

num = 100

def run():
    print("子进程开始")
    global num  #global表示引用全局变量num,  相当于num = 100
    n = 0
    while n < 4:
        num += 1
        n += 1
    print("子进程结束num:%d" %(num))

if __name__ == "__main__":
    print("父进程开始")

    p = Process(target=run)
    p.start()
    p.join()

    #在子进程中修改全局变量对父进程中的全局变量没有影响
    #在创建子进程时对全局变量做了一个备份,父进程中的与子进程中的num是完全不同的两个变量
    print("父进程结束num:%d" %(num))

结果如下:

父进程开始
子进程开始
子进程结束num:104
父进程结束num:100

六. 进程池pool

• 在使用Python进行系统管理时，特别是同时操作多个文件目录或者远程控制多台主机，并行操作可以节约大量的时间。如果操作的对象数目不大时，还可以直接使用Process类动态的生成多个进程，十几个还好，但是如果上百个甚至更多，那手动去限制进程数量就显得特别的繁琐，此时进程池就派上用场了。
  Pool类可以提供指定数量的进程供用户调用，当有新的请求提交到Pool中时，如果池还没有满，就会创建一个新的进程来执行请求。如果池满，请求就会告知先等待，直到池中有进程结束，才会创建新的进程来执行这些请求。
• 使用实例如下:

from multiprocessing import Process,Pool
import os,time,random

def run(name):
    print("子进程%d启动--%s"%(name , os.getpid()))
    start = time.time()
    time.sleep(random.choice([1,2,3]))
    end = time.time()
    print("子进程%d结束--%s--耗时%.2f"%(name , os.getpid(), end -start))
if __name__ == "__main__":
    print("父进程启动")
    #创建多个进程
    #进程池
    #表示可以同时执行的进程数量
    #Pool默认大小是CPU核心数
    pp = Pool()
    for i in range(10):
        #创建进程,放入进程池中统一管理
        pp.apply_async(run, args = (i,))
    #在调用join之前必须先调用close,并且调用close之后就不能再继续添加新的进程了
    pp.close()    #close以后进程池pp将被关闭,不能再继续向pp中加入新的进程.
    #进程池对象调用join,会等待进程池中所有的子进程结束完毕再去执行父进程
    pp.join()
    print("父进程结束")