欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Python第十二章-多进程和多线程01-多进程

程序员文章站 2022-03-20 15:49:38
多进程和多线程 一、进程 1.1 进程的引入 现实生活中,有很多的场景中的事情是同时进行的,比如开车的时候 手和脚共同来驾驶汽车,再比如唱歌跳舞也是同时进行的;试想,如果把唱歌和跳舞这2件事情分开依次完成的话,估计就没有那么好的效果了(想一下场景:先唱歌,然后在跳舞,O(∩_∩)O哈哈~) 程序中 ......

多进程和多线程

一、进程

1.1 进程的引入

现实生活中,有很多的场景中的事情是同时进行的,比如开车的时候 手和脚共同来驾驶汽车,再比如唱歌跳舞也是同时进行的;试想,如果把唱歌和跳舞这2件事情分开依次完成的话,估计就没有那么好的效果了(想一下场景:先唱歌,然后在跳舞,o(∩_∩)o哈哈~)

程序中

如下程序,来模拟“唱歌跳舞”这件事情

# 模拟唱歌,跳舞
from time import sleep


def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        sleep(1)


def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        sleep(1)


if __name__ == '__main__':
        sing()  # 唱歌
        dance() # 跳舞

运行结果

Python第十二章-多进程和多线程01-多进程

注意

  • 很显然刚刚的程序并没有完成唱歌和跳舞同时进行的要求
  • 如果想要实现“唱歌跳舞”同时进行,那么就需要一个新的方法,叫做:多任务

1.2 多任务的概念

什么叫“多任务”呢?简单地说,就是操作系统可以同时运行多个任务。打个比方,你一边在用浏览器上网,一边在听mp3,一边在用word赶作业,这就是多任务,至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着,只是桌面上没有显示而已。
Python第十二章-多进程和多线程01-多进程

现在,多核cpu已经非常普及了,但是,即使过去的单核cpu,也可以执行多任务。由于cpu执行代码都是顺序执行的,那么,单核cpu是怎么执行多任务的呢?

答案就是操作系统轮流让各个任务交替执行,任务1执行0.01秒,切换到任务2,任务2执行0.01秒,再切换到任务3,执行0.01秒……这样反复执行下去。表面上看,每个任务都是交替执行的,但是,由于cpu的执行速度实在是太快了,我们感觉就像所有任务都在同时执行一样。

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

其实就是cpu执行速度太快啦。。

Python第十二章-多进程和多线程01-多进程

1.2.1 进程

每个独立执行的程序称为进程

进程是程序的一次动态执行过程,它经历了从代码加载、执行到执行完毕的一个完整过程,这个过程也是进程本身从产生、发展到最终消亡的过程。

多进程(多任务)操作系统能同时运行多个进程(程序),由于cpu具备分时机制,所以每个进程都能循环获得自己的cpu时间片。由于cpu执行速度非常快,使得所有程序好象是在“同时”运行一样。

在操作系统中进程是进行系统资源分配、调度和管理的最小单位,进程在执行过程中拥有独立的内存单元。

比如:windows采用进程作为最小隔离单位,每个进程都有自己的数据段、代码段,并且与别的进程没有任何关系。因此进程间进行信息交互比较麻烦。

进程也可以通过派生 (fork 或 spawn)新的进程来执行其他任务,不过因为每个新进程也都拥有自己的内存和数据栈等,所以只能采用进程间通信(ipc)的方式共享信息。

1.2.2 线程

为了解决进程调度资源的浪费,为了能够共享资源,出现了线程。有时候把线程称之为轻量级进程.

线程是cpu调度和分派的基本单位,它可与同属一个进程的其他的线程共享进程所拥有的全部资源,多个线程共享内存,从而极大地提高了程序的运行效率。

线程是比进程更小的执行单位,线程是进程内部单一的一个顺序控制流。

所谓多线程是指一个进程在执行过程中可以产生多个线程,这些线程可以同时存在、同时运行,形成多条执行线索。一个进程可能包含了多个同时执行的线程。

一个或更多的线程构成了一个进程(操作系统是以进程为单位的,而进程是以线程为单位的,进程中必须有一个主线程main)

如果一个进程没有了,那么这个进程内的所有线程肯定会消失,如果线程消失了,但是进程未必会消失。只有所有的线程都结束了,进程才会结束!!!而且所有线程都是在进程的基础之上同时运行。

1.3 python 和并发编程

在大多数系统上, python支持多进程(基于消息传递)编程和多线程编程.

大多数人比较熟悉的是多线程编程, 但是在python中的多线程编程却是有诸多的限制.

python中多线程的限制

为了线程安全考虑, python的解释器还是使用了内部的gil(global interperter lock, 全局解释器锁定), 在任意时刻只运行单个python的线程执行.即使有多个可用的cpu核心, 也是如此.这就限制了python只能在一个cpu核心上运行.

gil的存在直接影响了程序的并发编程问题.

如果一个应用程序是大部分与i/o相关, 那么使用线程一般没有问题, 因为大部分时间是在i/o等待.

如果一个应用程序是cpu密集型的, 则使用多线程的坏处大于好处, 返回会降低程序的运行速度, 一般比你想象的还要慢的多.

因此, 用户在有些情况需要使用多进程(子进程和消息传递)

子进程和消息传递
展望未来, 如果要再python中进行各种类型的并发编程, 消息传递应该是最应该掌握的概念.

1.4 multiprocessing包

multiprocessing是一个package, 这个包支持使用类似threading模块的类似api去创建新的进程.

multiprocessing支持本地和远程并发编程, 通过使用子进程来代替线程高效的规避了gil问题.

所以, multiprocessing允许程序员重复利用给定计算机的多核cpu.

由于python的跨平台, 所以multiprocessing支持多个平台:unix, window, linux.

1.4.1 process类

process语法结构如下:

process([group [, target [, name [, args [, kwargs]]]]])

  • target:表示这个进程实例所调用对象;
  • args:表示调用对象的位置参数元组;
  • kwargs:表示调用对象的关键字参数字典;
  • name:为当前进程实例的别名;
  • group:大多数情况下用不到;

最简单的使用代码:

# 从multiprocessing中导入process
from multiprocessing import process
import os


# 子进程要执行的代码
def run_proc(name):
    print('子进程运行中,hello,= %s ,pid=%d...' % (name, os.getpid()))


if __name__ == '__main__':  # 判断是否为主程序
    print('父进程 %d.' % os.getpid())
    """
    创建process对象, 表示一个子进程.
    1. target参数表示子进程要做的任务(一个可执行对象)
    2. args是一个元组, 表示传递给target的可执行对象的位置参数.
        本例中就是把"王二狗"传递给函数f的name参数
    """
    p = process(target=run_proc, args=('王二狗',))
    print('子进程将要执行。。')
    p.start() # 启动子进程
    p.join() # 等待进程终止
    print("子进程已经终止")

说明

  1. 创建子进程时,只需要传入一个执行函数和函数的参数,创建一个process实例,用start()方法启动。
  2. join()方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。
1.4.1.1 process类的实例具有以下方法

process实例p具有以下方法:

  1. p.start()

    启动子进程. 这将运行代表进程的子进程, 并调用该子进程中的p.run()方法.

  2. p.join([timeout])

    等待进程p终止, timeout是可选的超时时间. 这个方法通常用户进程间的同步.

  3. p.is_alive()

    测试进程p是否还在运行, 如果扔在运行, 则返回true

  4. run():

    如果没有给定target参数,对这个对象调用start()方法时,就将执行对象中的run()方法;

  5. p.terminate()

    强制终止p进程. 如果调用此方法, 进程p将立即被终止, 同时不会进行任何清理工作. 如果再进程p中也开启了子进程, 则这些子进程将成为僵死进程.s如果p保存了一个锁定或有进程间通信, 那么终止可能会导致死锁或i/o崩溃.

1.4.1.2 process实例具有以下实例属性:

process实例p具有以下实例属性:

  1. p.daemon

    一个布尔标志, 指示这个进程是否为后台进程. 当创建他的python进程终止时, 后台进程将自动终止.

    另外禁止后台进程创建自己的新进程. p.daemon的值必须再进程启动前设置.

  2. p.exitcode

    进程的整数退出码. 如果进程仍在运行, 则它的值是none. 如果是负数, -n表示由信号n所终止

  3. p.name

    当前进程实例别名,默认为process-n,n为从1开始递增的整数;

  4. p.pid

    进程的整数id

1.4.1.3 实例

实例1:

from multiprocessing import process
import os
from time import sleep


# 子进程要执行的代码
def run_proc(name, age, **kwargs):
    for i in range(10):
        print('子进程运行中,name= %s,age=%d ,pid=%d...' % (name, age,os.getpid()))
        print(kwargs)
        sleep(0.5)


if __name__=='__main__':
    print('父进程 %d.' % os.getpid())
    p = process(target=run_proc, args=('test',18), kwargs={"m":20})
    print('子进程将要执行')
    p.start()
    sleep(1)
    p.terminate()
    p.join()
    print('子进程已结束')

运行结果:

Python第十二章-多进程和多线程01-多进程

实例2:

from multiprocessing import process
import time
import os


# 两个子进程将会调用的两个方法
def worker_1(interval):
    print("worker_1,父进程(%s),当前进程(%s)"%(os.getppid(), os.getpid()))
    t_start = time.time()
    time.sleep(interval)  # 程序将会被挂起interval秒
    t_end = time.time()
    print("worker_1,执行时间为'%0.2f'秒" % (t_end - t_start))


def worker_2(interval):
    print("worker_2,父进程(%s),当前进程(%s)" % (os.getppid(), os.getpid()))
    t_start = time.time()
    time.sleep(interval)
    t_end = time.time()
    print("worker_2,执行时间为'%0.2f'秒" % (t_end - t_start))


if __name__ == '__main__':  # 判断是否为主程序
    # 输出当前程序的id
    print("进程id:%s" % os.getpid())

    """
    创建两个进程对象,target指向这个进程对象要执行的对象名称,
    args后面的元组中,是要传递给worker_1方法的参数,
    因为worker_1方法就一个interval参数,这里传递一个整数2给它,
    如果不指定name参数,默认的进程对象名称为process-n,n为一个递增的整数
    """
    p1=process(target=worker_1, args=(2,))
    p2=process(target=worker_2, name="王二狗", args=(1,))

    # 使用"进程对象名称.start()"来创建并执行一个子进程,
    # 这两个进程对象在start后,就会分别去执行worker_1和worker_2方法中的内容
    p1.start()
    p2.start()

    # 同时父进程仍然往下执行,如果p2进程还在执行,将会返回true
    print("p2.is_alive=%s " % p2.is_alive())

    # 输出p1和p2进程的别名和pid
    print("p1.name=%s" % p1.name)
    print("p1.pid=%s" % p1.pid)
    print("p2.name=%s" % p2.name)
    print("p2.pid=%s" % p2.pid)


    """
    join括号中不携带参数,表示父进程在这个位置要等待p1进程执行完成后,再继续执行下面的语句,一般用于进程间的数据同步
    如果不写这一句,下面的is_alive判断将会是true,
    改成p1.join(1),
    因为p2需要2秒以上才可能执行完成,父进程等待1秒很可能不能让p1完全执行完成,所以下面的print会输出true,即p1仍然在执行
    """
    p1.join()
    print("p1.is_alive=%s" % p1.is_alive())

运行结果:

Python第十二章-多进程和多线程01-多进程

1.4.1.4 进程的创建-process子类

创建新的进程还能够使用类的方式,可以自定义一个类,继承process类,每次实例化这个类的时候,就等同于实例化一个进程对象

示例代码:

from multiprocessing import process
import time
import os


# 继承process类
class processclass(process):
    """
    因为process类本身也有__init__方法,这个子类相当于重写了这个方法,
    但这样就会带来一个问题,我们并没有完全的初始化一个process类,所以就不能使用从这个类继承的一些方法和属性,
    最好的方法就是将继承类本身传递给process.__init__方法,完成这些初始化操作
    """
    def __init__(self,interval):
        process.__init__(self)
        self.interval = interval

    # 重写了process类的run()方法
    def run(self):
        print("子进程(%s) 开始执行,父进程为(%s)" % (os.getpid(), os.getppid()))
        t_start = time.time()
        time.sleep(self.interval)
        t_stop = time.time()
        print("(%s)执行结束,耗时%0.2f秒"%(os.getpid(), t_stop-t_start))


if __name__ == "__main__":
    t_start = time.time()
    print("当前程序进程(%s)"%os.getpid())
    p1 = processclass(2)
    # 对一个不包含target属性的process类执行start()方法,就会运行这个类中的run()方法,所以这里会执行p1.run()
    p1.start()
    p1.join()
    t_stop = time.time()
    print("(%s)执行结束,耗时%0.2f"%(os.getpid(),t_stop-t_start))

运行结果:

Python第十二章-多进程和多线程01-多进程

1.4.2 进程池:pool

当需要创建的子进程数量不多时,可以直接利用multiprocessing中的process动态成生多个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的pool方法。使用类pool可以创建进程池, 然后把各种数据处理任务都提交给进程池.

初始化pool时,可以指定一个最大进程数,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到指定的最大值,那么该请求就会等待,直到池中有进程结束,才会创建新的进程来执行

pool([numprocess, initializer, initargs])

说明:

numprocess 是指要创建的线程数. 默认是cpu的核心数.(os.cpu_count()的返回值)

initializer 是每个进程启动时要执行的可调用对象, 默认是none

initargs是传递给initializer的元组参数.

1.4.2.1 multiprocessing.pool常用函数解析:
  • apply(func[, args[, kwds]]):使用阻塞方式调用func

    在进程池的一个工作进程中执行func函数, args是传给func的元组参数. 注意使用这个方法让多个进程去执行, 他们是同步执行的. 即:多个进程是顺序执行的.
    func的返回值就是p.apply的返回值.

  • apply_async(func[, args, kwargs, callback]) :使用非阻塞方式调用func

    (并行执行,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给func的参数列表,kwds为传递给异步的执行func

    callback 是可调用对象, 当func执行结束, 则立即调用callback并把func的返回值传递给callback.

  • func的关键字参数列表;

  • close():关闭pool,使其不再接受新的任务;

  • terminate():不管任务是否完成,立即终止;

  • join():主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用;

asyncresult对象(apply_async()的返回值)

apply_async()的返回值是asyncresult实例. 具有如下方法:

  1. a.get([timeout])

等待返回结果, 结果就是任务函数的返回值.

  1. a.ready()

如果任务函数执行结束返回true

  1. a.successful()

如果任务函数执行结束, 且在执行的过程中没有发生异常则

  1. a.wait([timeout])

等待任务结束, 这个方法与get()的区别就是它没有返回值.