多进程和多线程

时间:2021-02-04 16:42:55

进程的概念

进程:一个正在执行的程序

  • 计算机程序是存储在磁盘上的可执行二进制(或其他类型)文件,只有把它们加载到内存中,并被操作系统调用,它们才会拥有其自己的生命周期。
  • 进程是表示的一个正在执行的程序。
  • 每个进程都拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据。
  • 操作系统负责其上所有进程的执行,并为这些进程合理地分配执行时间。
  • 进程之间是独立的,不能共享彼此的数据。

并行与并发

并行:同时进行多个任务
并发:短时间内,运行多个任务

并发:单CPU,多进程并发

     无论是并行还是并发,在用户看来都是'同时'运行的,不管是进程还是线程,都只是一个任务而已,真实干活的是cpu,cpu来做这些任务,而一个cpu同一时刻只能执行一个任务

      一 并发:是伪并行,即看起来是同时运行。单个cpu+多道技术就可以实现并发,(并行也属于并发)

多进程和多线程

并行:多CPU(同时运行,只有具有多个cpu才能实现并行)

 多进程和多线程

并行满足的条件是总进程数量不多于 CPU核心数量!因此,现在PC运行的程序大部分都是轮询调度产生的并行假象

举例:比如PC有四个核,六个任务,这样同一时间有四个任务被执行,假设分别被分配给了cpu1,cpu2,cpu3,cpu4,

   一旦任务2遇到I/O就*中断执行,此时任务5就拿到cpu1的时间片去执行,这就是单核下的多道技术

   而一旦任务2的I/O结束了,操作系统会重新调用它(需知进程的调度、分配给哪个cpu运行,由操作系统说了算),可能被分配给四个cpu中的任意一个去执行

  所以,现代计算机经常会在同一时间做很多件事,一个用户的PC(无论是单cpu还是多cpu),都可以同时运行多个任务(一个任务可以理解为一个进程)。

多道技术:内存中同时存入多道(多个)程序,cpu从一个进程快速切换到另外一个,使每个进程各自运行几十或几百毫秒,这样,虽然在某一个瞬间,一个cpu只能执行一个任务,但在1秒内,cpu却可以运行多个进程,这就给人产生了并行的错觉,即伪并发,以此来区分多处理器操作系统的真正硬件并行(多个cpu共享同一个物理内存)

 

例子:在python中执行耗时操作

多进程和多线程

 结果:

多进程和多线程

用进程来分担耗时任务后:

多进程和多线程

多进程和多线程

python进程使用流程

多进程和多线程

 

 

线程的概念

  • 线程被称作轻量级进程。
  • 与进程类似,不过它们是在同一个进程下执行的。
  • 并且它们会共享相同的上下文。
  • 当其他线程运行时,它可以被抢占(中断)和临时挂起(也称为睡眠)
  • 线程的轮训调度机制类似于进程的轮询调度,只不过这个调度不是由操作系统来负责,而是由Python解释器来负责。

GIL锁

Python在设计的时候,还没有多核处理器的概念。因此,为了设计方便与线程安全,直接设计了一个锁。这个锁要求,任何进程中,一次只能有一个线程在执行。
因此,并不能为多个线程分配多个CPU。所以Python中的线程只能实现并发,而不能实现真正的并行。但是Python3中的GIL锁有一个很棒的设计,在遇到阻塞(不是耗时)的时候,会自动切换线程。

Scrapy、Django、Flask、Web2py ...等框架 都是使用多线程来完成
GIL锁带给我们的新认知,遇到阻塞就自动切换。因此我们可以利用这种机制来有效的避开阻塞 ,充分利用CPU

例子:使用线程来避开阻塞任务

多进程和多线程

多进程和多线程

python线程使用流程

 多进程和多线程

计算密集型和IO密集型

IO密集型遇到等待时,不消耗CPU,CPU会调度其他程序执行,使用多线程可以有效的进行并发(爬虫的请求是IO密集型),线程在系统中所占资源较少。
计算密集型:CPU会一直计算,此时使用多线程,反而会耗时更多,此时使用多进程(CPU越多,性能越好)。

使用多进程/多线程实现并发服务器:

import socket
from multiprocessing import Process
from threading import Thread


def read(conn,addr):
    while True:
        data = conn.recv(1024)
        if data:
            print('客户端{}的消息:{}'.format(addr,data.decode()))
            conn.send(data)
        else:
            conn.close() 
            print('客户端{}断开连接'.format(addr))
            break


if __name__ == '__main__':
    server = socket.socket()
    server.bind(('', 9998)) # 注意这些代码要写在if...main...判断下面,因为在Windows中,使用进程的模式类似导入,在判断外面的代码会在子进程执行
    server.listen(5)
    while True:
        print('等待客户端连接')
        conn,addr = server.accept()  # 有客户端连接,就往下进行
        print('客户端{}已连接'.format(addr))
        # p = Process(target=read,args=(conn,addr))  # 使用多进程,每来一个客户端连接,就分出一个进程去和它一对一处理
        # p.start()
        t = Thread(target=read,args=(conn,addr))  # 使用多线程,每来一个客户端连接,就分出一个线程去和它一对一处理
        t.start()

补充

fork介绍

Unix/Linux操作系统提供了一个fork()系统调用,它非常特殊。普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回。

子进程永远返回0,而父进程返回子进程的ID。这样做的理由是,一个父进程可以fork出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用getppid()就可以拿到父进程的ID。

import os

if __name__ == '__main__':

    print('进程 (%s) start...' % os.getpid())
    pid = os.fork()
    # time.sleep(10)
    if pid == 0:  # 若fork()返回0为子进程
        print("子进程{},父进程{}".format(os.getpid(), os.getppid())) #getpid()获取当前进程的pid,getppid()获取父进程的pid
    else:  # 父进程fork返回子进程的id
        print("父进程{},子进程{}".format(os.getpid(), pid))

>>
进程 (3130) start...
父进程3130,子进程3131
子进程3131,父进程3130

multiprocessing模块介绍

python中的多线程无法利用CPU资源,在python中大部分计算密集型任务使用多进程。如果想要充分地使用多核CPU的资源(os.cpu_count()查看)

python中提供了非常好的多进程包multiprocessing。

multiprocessing模块用来开启子进程,并在子进程中执行功能(函数),该模块与多线程模块threading的编程接口类似。

multiprocessing的功能众多:支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件。

 计算密集型任务:如金融分析,科学计算

multiprocessing.current_process() :在任何一个进程中搞清楚自己是谁,在线程中也有类似方法

多进程和多线程

Process类的介绍

1.创建进程的类

Process([group [, target [, name [, args [, kwargs]]]]]),由该类实例化得到的对象,表示一个子进程中的任务(尚未启动)

强调:
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号

2.参数介绍

group参数未使用,值始终为None

target表示调用对象,即子进程要执行的任务

args表示调用对象的位置参数元组,args=(1,2,'al',)

kwargs表示调用对象的字典,kwargs={'name':'al','age':18}

name为子进程的名称

 

3.方法介绍

p.start():启动进程,并调用该子进程中的p.run() 
p.run():进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法  

p.terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况。
如果p还保存了一个锁那么也将不会被释放,进而导致死锁,线程中无此方法
p.is_alive():如果p仍然运行,返回True

p.join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)再往下运行。timeout是可选的超时时间,
需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程

4.属性介绍

p.daemon:默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置

p.name:进程的名称

p.pid:进程的pid,线程中是t.ident 注意只有进程或线程已经启动才会分配pid或ident

p.exitcode:进程在运行时为None、如果为–N,表示被信号N结束(了解即可)

p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,
这类连接只有在具有相同的身份验证键时才能成功(了解即可)

以用面向对象的形式使用进程与线程

关键点:

  • 继承Process或Thread类
  • 重写__init__方法
  • 重写run方法
from multiprocessing import Process
import time
import random
import os
class pro(Process): #继承Process类 def __init__(self,name): super().__init__() # 重写__init__方法 这里是直接调用父类的初始化方法 self.name = name
def run(self): # 重写run方法 print('%s is working,父进程%s,当前进程%s'%(self.name,os.getppid(),os.getpid())) time.sleep(1) print('%s end'%self.name)

if __name__ =='__main__': p1 = pro('a') p2 = pro('b') p3 = pro('c') p1.start() p2.start() p3.start() print('主进程',os.getpid()) >> 主进程 9116 b is working,父进程9116,当前进程4316 a is working,父进程9116,当前进程6664 c is working,父进程9116,当前进程10132 b end a end c end

 总结:

Windows用的导入(所以if...main...判断外面的代码,在子进程仍会执行)

方法:
p = Process(target=func,name='p1',daemon=True) #实例的时候可以指定方法、名字、是否守护进程
p.current_process() 获取当前进程对象
p.is_alive() 判断进程实例是否在运行 是返回True 否返回False
p.terminate() 结束进程 线程无此方法
p.name 获取进程名字
p.join() 等待子进程结束再往下执行
p.daemon = True 把进程设为守护进程 (父进程结束,守护进程也结束)
注意:如果设置了join() 那么terminate和daemon 就不管用啦
p.pid 获取当前进程的pid  线程是t.ident  
注意:只有进程(或线程)启动之后,操作系统(或python解释器)才会分配pid(或ident)

默认在子进程当中,会关闭标准输入
import sys
import os
sys.stdin = os.fdopen(0) #加上这行代码,子进程才能使用标准输入

多线程的方法与属性
t.setDaemon(True)
t.setName('p1')
t.getName()