进程与线程的使用在代码运行效率的优化上是一个不可或缺的技能，看完本篇文章，你将对进程与线程有一定的了解。

1. 多任务深入理解

1.1. CPU时间片

在单核中，并行基本上是并发，只有多核才能真正实现并行。

1.2. 进程的概念

每个进程拥有自己的独立的地址空间，内存，数据栈，以及其它用于跟踪执行的辅助数据。
各个进程之间相互独立，互不影响。

2. 多进程实现

2.1. 单一进程

使用睡眠来模拟耗时操作，查看整个程序的运行时间。

'''单进程'''
import time

def new_time():
    """格式化时间"""
    # print(time.time())
    # outputs:1638166819.3935854，时间戳，是从1970年1月1日开始所经过的秒数
    # print(time.localtime(time.time()))
    # outputs:time.struct_time(tm_year=2021, tm_mon=11, tm_mday=29, tm_hour=14, tm_min=20, tm_sec=19, tm_wday=0, tm_yday=333, tm_isdst=0)，将时间戳转换成年月日时分秒
    # print(time.asctime(time.localtime(time.time())))
    # outputs:Mon Nov 29 14:20:19 2021
    return time.asctime(time.localtime(time.time()))

def func():
    print('inner-start:',new_time())
    time.sleep(5)       # 休眠，模拟io耗时操作
    print('inner-end:',new_time())

print('outer-start:',new_time())
time.sleep(5)
func()
print('outer-end:',new_time())

运行结果

2.2. 开启多进程

使用多进程来分担耗时任务，在另一个进程中运行耗时任务，这样主进程就不会受到影响。当子进程执行完时，返回子进程的运行结果。

'''开启多进程不包含参数'''
import multiprocessing     # 导入多进程模块
import time

def new_time():
    """格式化时间"""
    # print(time.time())
    # outputs:1638166819.3935854，时间戳，是从1970年1月1日开始所经过的秒数
    # print(time.localtime(time.time()))
    # outputs:time.struct_time(tm_year=2021, tm_mon=11, tm_mday=29, tm_hour=14, tm_min=20, tm_sec=19, tm_wday=0, tm_yday=333, tm_isdst=0)，将时间戳转换成年月日时分秒
    # print(time.asctime(time.localtime(time.time())))
    # outputs:Mon Nov 29 14:20:19 2021
    return time.asctime(time.localtime(time.time()))

def func():
    print('inner-start:',new_time())
    time.sleep(5)       # 休眠，模拟io耗时操作
    print('inner-end:',new_time())

print('outer-start:',new_time())
p1 = multiprocessing.Process(target=func)      # 实例化一个进程对象，target告诉它做什么事
p1.start()      # 开启子进程，能够让任务更快地做完
time.sleep(5)
print('outer-end:',new_time())

运行结果

可以发现做同样的工作，运行多进程程序比运行单进程程序快了5秒钟。

'''开启多进程包含参数'''
import multiprocessing     # 导入多进程模块
import time

def new_time():
    """格式化时间"""
    # print(time.time())
    # outputs:1638166819.3935854，时间戳，是从1970年1月1日开始所经过的秒数
    # print(time.localtime(time.time()))
    # outputs:time.struct_time(tm_year=2021, tm_mon=11, tm_mday=29, tm_hour=14, tm_min=20, tm_sec=19, tm_wday=0, tm_yday=333, tm_isdst=0)，将时间戳转换成年月日时分秒
    # print(time.asctime(time.localtime(time.time())))
    # outputs:Mon Nov 29 14:20:19 2021
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('inner-start:',new_time())
    print(x*y)
    time.sleep(5)       # 休眠，模拟io耗时操作
    print('inner-end:',new_time())

print('outer-start:',new_time())
p1 = multiprocessing.Process(target=func,args=(3,4))      # 实例化一个进程对象，target告诉它做什么事，必须得传元组，所以单个参数时需要(3,)
p1.start()      # 开启子进程，能够让任务更快地做完
time.sleep(5)
print('outer-end:',new_time())

运行结果

2.3. 多进程

首先是multiprocessing.Process实例化，并且指定回调函数，参数列表。
实例化之后可以直接调用运行，这就实现了多进程运行，节省运行时间。
这里并行都只是Python层面的，并不是实际层面的。
当总进程数多于核心数的时候，多余的进程就没有了效果。
多进程是由操作系统调度运行。

代码实现过程

3. 多线程实现

3.1. 轻量级进程

如果把进程比做一个工厂，那么线程就是工厂里面的工人，也就是一个进程可以包含多个线程。
车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内容空间是共享的，每个线程都可以使用这些共享内存。
一个线程可以被抢占（中断）也可以临时挂起（睡眠）等。
线程的调度由Python解释器调度，而进程由操作系统调度。

3.2. 多线程

多线程不适合解决计算密集型的情形，但是适合IO密集型的场景。因为在同一个进程内，并不会额外分配其它的系统资源。
Python中的多线程在遇到阻塞时，会自动切换到非阻塞的线程上去。

'''多线程实现'''
import time
import multiprocessing     # 导入多进程模块
import threading        # 导入多线程模块

def new_time():
    """格式化时间"""
    # print(time.time())
    # outputs:1638166819.3935854，时间戳，是从1970年1月1日开始所经过的秒数
    # print(time.localtime(time.time()))
    # outputs:time.struct_time(tm_year=2021, tm_mon=11, tm_mday=29, tm_hour=14, tm_min=20, tm_sec=19, tm_wday=0, tm_yday=333, tm_isdst=0)，将时间戳转换成年月日时分秒
    # print(time.asctime(time.localtime(time.time())))
    # outputs:Mon Nov 29 14:20:19 2021
    return time.asctime(time.localtime(time.time()))

def func(x,y):
    print('inner-start:',new_time())
    print(x*y)
    time.sleep(5)       # 休眠，模拟io耗时操作
    print('inner-end:',new_time())

print('outer-start:',new_time())
t1 = threading.Thread(target=func,args=(3,4))       # 实例化一个线程对象
t1.start()      # 开启子线程
time.sleep(5)
print('outer-end:',new_time())

运行结果

3.3. GIL全局解释锁

Python发明之初，还没有多核CPU的概念。为了利用多核，Python开始支持多线程，而解决多线程之间数据完整性和状态同步的最简单方法自然就是加锁，于是就有了GIL这把全局解释锁。
GIL锁要求，任何进程中，一次只能有一个线程在执行，因此，并不能为多个线程分配多个CPU，所以Python中的线程只能实现并发，而不能实现并行。

4. 并发服务器

4.1. 多进程实现并发服务器

'''多进程实现并发服务器'''
import time
import socket
import multiprocessing
server = socket.socket()
server.bind(('127.0.0.1',8989))
server.listen(10)

def handle(conn):
    while True:
        recv_data = conn.recv(1024)
        if recv_data:
            print(recv_data)
            conn.send(recv_data)
        else:
            conn.close()
            break

while True:
    conn,address = server.accept()      # 生成套接字
    p1 = multiprocessing.Process(target=handle,args=(conn,))
    p1.start()

4.2. 多线程实现并发服务器

'''多线程实现并发服务器'''
import time
import socket
import threading

server = socket.socket()
server.bind(('127.0.0.1',8989))
server.listen(10)

def handle(conn):
    while True:
        recv_data = conn.recv(1024)
        if recv_data:
            print(recv_data)
            conn.send(recv_data)
        else:
            conn.close()
            break

while True:
    conn,address = server.accept()      # 生成套接字
    t1 = threading.Thread(target=handle,args=(conn,))
    t1.start()

4.3. 进程与线程认识客户端

import socket
client = socket.socket()        # 创建一个socket对象，命名为客户端
client.connect(('127.0.0.1',8989))# 连接服务器端口，注意这里填入的是元组

for i in range(1000):
    client.send(b'hello')       # 发送hello给服务器
    print(client.recv(1024))

文章到这里就结束了！希望大家能多多支持Python（系列）！六个月带大家学会Python，私聊我，可以问关于本文章的问题！以后每天都会发布新的文章，喜欢的点点关注！一个陪伴你学习Python的新青年！不管多忙都会更新下去，一起加油！

Editor：Lonelyroots