Python之多线程与多进程

? 最近一直在学习爬虫的知识，遇到了很多坎坷也同时学到了很多以往从未接触到的知识和领域。我想，学习的点滴进步就在于遇到一个一个问题然后又一个一个解决中积累起来的吧，乐趣也在于此，引用一句话“谁学谁知道啊”😀。

------引用一句史蒂夫?乔布斯的名言：生活不会突变，你要做的只是耐心和积累。人这一辈子没法做太多事情，所以每一件都要做得精彩绝伦。

下面进入正题，目前爬虫技术已经应用非常广泛。当爬取数据量非常大时，就要考虑如何提高爬虫效率。如果使用单线程的爬虫，爬取数据的速度是非常慢的。那么解决的办法就是使用Python中的多线程和多进程，这样就可以实现同时完成多项工作，提高执行效率。

1.1 进程与线程

1.1.1 什么是进程

? 在了解进程之前，我们有必要知道多任务多概念。多任务，顾名思义，就是指操作系统能够执行多个任务。像我们使用Windows和Linux操作系统可以同时看电影、打字、查看网页等等，这就是操作系统在执行多任务，而每一个任务就是一个进程。我以Mac系统为例，查看进程

# 执行命令,查看进程号
ps -ef | grep 进程名
# demo
liuxiaowei@MacBookAir ~ % ps -ef | grep 3306
501 5102 854   0 5:45PM ttys000     0:00.00 grep 3306

# 执行命令,查看进程
liuxiaowei@MacBookAir ~ $sudo lsof -i

上图中显示的进程只是一部分截图，包括电脑运行的各种应用程序。进程(Process)

1.1.2 什么是线程

线程(Thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每条线程并行执行不同的任务。这可以打个比方：视频播放这个进程中，显示视频用一个线程，播放音频是一个线程。只有两个线程同时工作，我们才能正常观看画面和声音同步的视频。进程好比一列火车，而线程好比车厢，线程需要在进程下进行，就好比单独的车厢无法行驶一样。一个进程可以包含很多线程，就像火车有很多车厢一样。

1.2创建线程

Python语言内置多线程支持，它的标准库提供了两个模块：_thread和threading, _thread是低级模块，threading是高级模块,对 _thread进行封装。绝大多数情况我们只使用threading这个高级模块。

1.2.1 使用threading模块创建线程

# Pycharm环境python3.9
#_*_coding:utf-8_*_
# 作者      ：liuxiaowei
# 创建时间   ：1/15/22 6:42 PM
# 文件      ：threading创建线程.py
# IDE      ：PyCharm

import threading,time

def process():
    for i in range(5):
        time.sleep(1)
        print("thread name is %s" % threading.current_thread().name)
if __name__ == "__main__":
    print("------主线程开始-----")
    
# 创建4个线程，存入列表
    threads = [threading.Thread(target=process) for i in range(4)]
    for t in threads:
        t.start()       # 开启线程
    for t in threads:
        t.join()        # 等待子线程结束
    print("-----主线程结束-----")

上述代码中，创建了4个线程，然后分别用for循环执行4次start()和join()方法。每个字线程分别执行5次。运行结果如下：

注：从中可以看出线程的执行顺序是不确定的

1.2.2 使用Thread子类创建线程

# Thread线程累也可以通过定义一个继承Thread线程类的子类来创建线程SubThread,并定义一个方法(),实例化SubThread类创建2个线程，并且调用start()方法开启线程，会自动调用run()方法
#_*_coding:utf-8_*_
# 作者      ：liuxiaowei
# 创建时间   ：1/15/22 7:51 PM
# 文件      ：Thread子类创建线程.py
# IDE      ：PyCharm

import threading
import time
class SubThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "子线程" + self.name + "执行，i=" + str(i)  # name属性中保存的是当前线程的名字
            print(msg)

if __name__ == "__main__":
    print("------主线程------")
    t1 = SubThread()                       # 创建子线程t1
    t2 = SubThread()                       # 创建子线程t2
    t1.start()                             # 启动子线程t1
    t2.start()                             # 启动子线程t2
    t1.join()                              # 等待子线程t1
    t2.join()                              # 等待子线程t2
    print("------主线程结束------")```

1.3 创建进程

1.3.1创建进程的常用方式

1.3.1.1 使用multiprocessing模块创建进程

# 实例化进程
from multiprocessing import Process             # 导入模块

# 执行子进程代码
def test(interval):
    print('我是子进程')

# 执行主程序
def main():
    print("主进程开始")
    p = Process(target = test, args = (1, ))            # 实例化Process进程类
    p.start()                                           # 启动子进程
    print('主进程结束')
if __name__ == '__main__':
		main()

1.3.1.2 使用Process子类创建进程

#_*_coding:utf-8_*_
# 作者      ：liuxiaowei
# 创建时间   ：1/15/22 9:03 PM
# 文件      ：使用Process子类创建进程.py
# IDE      ：PyCharm

from multiprocessing import Process
import time
import os

# 继承Process类
class SubProcess(Process):
    # 由于Process类本身也有__init__初始化方法，这个子类相当于重写类子父类的这个方法
    def __init__(self, interval, name = ''):
        Process.__init__(self)              # 调用Process父类的初始化方法
        self.interval = interval            # 接收参数interval

        if name:                            # 判断传递的参数name是否存在
            self.name = name                # 如果传递参数name,则为了子进程创建name属性，否则使用默认属性
    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__":
    print("-----父进程开始执行------")
    print("父进程PID： %s" %os.getpid())       # 输出当前程序的ID
    p1 = SubProcess(interval=1, name='mrsoft')
    p2 = SubProcess(interval=2)
    # 对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法
    # 所以这里不会执行p1.run()
    p1.start()                      # 启动进程p1
    p2.start()                      # 启动进程p2
    # 输出p1和p2进程的执行状态，如果真正进行，返回True, 否则返回Fasle
    print("p1.is_alive=%s"%p1.is_alive())
    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)
    print("-------等待子进程-------")
    p1.join()               # 等待p1进程结束
    p2.join()               # 等待p2进程结束
    print("-------父进程执行结束-------")

1.3.1.3 使用进程池Pool创建进程

# 定义一个进程池，设置最大进程数为3，然后使用非阻塞方式执行10个任务，查看每个进程执行的任务
#_*_coding:utf-8_*_
# 作者      ：liuxiaowei
# 创建时间   ：1/15/22 9:52 PM
# 文件      ：使用进程池创建进程.py
# IDE      ：PyCharm


from multiprocessing import Pool
import os, time


def task(name):
    print('子进程 （%s)执行task %s ...' %(os.getpid(), name))
    time.sleep(1)               # 休眠1秒
    
if __name__ == '__main__':
    print('父进程(%s) .' %os.getpid())
    p = Pool(3)                 # 定义一个进程池，最大进程数3
    for i in range(10):         # 从0开始循环10次
        p.apply_async(task, args=(i,))  # 使用非阻塞方式调用task()函数
    print('等待所有子进程结束...')
    p.close()                   # 关闭进程池，关闭后p不再接收新的请求
    p.join()                    # 等待子进程结束
    print('所有子进程结束.')