多进程和多线程

时间  2020-12-20

进程的概念

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

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

并行与并发

并行：同时进行多个任务
并发：短时间内，运行多个任务

并发：单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()
联系我们 沪ICP备2021010478号-7