进程和线程

为什么数据分析中不要Python内置数据类型，而使用numpy或pandas？

1. numpy和pandas的数据结构是要优于python内置的结构；
2. numpy中默认采用多线程的方式处理数据；
3. numpy底层是采用c来处理数据。

一、进程

• 进程是操作系统进行资源分配的基本单位，是Python程序中实现多任务的一种方式。每一个进程会单独占用一块内存。
• 一个程序运行后至少有一个进程，一个进程默认有一个线程，进程里面可以创建多个线程，线程是依附在进程里面的，没有进程就没有线程。
• 并行：多个CPU同时处理多个程序；
• 并发：一个CPU在很短的时间段内在多个程序之间来回切换执行的过程。

1.1 创建多进程的方法

• 步骤：

1. 导入多进程包：from multiprocessing import Process，windon系统要把多进程包放在执行语句里面。
2. 定义函数
3. 创建进程：p1 = Process(target=‘函数名’)，Process函数中必须包含一个target参数，指定创建进程的函数。
4. 执行进程：p1.start()

1、导入多进程的包
from multiprocessing import Process

2、定义两个函数，用多进程的方法处理
import time
def run1():
    for i in range(5):
        print(f'run1-{i}')
        time.sleep(1)
def run2():
    for i in range(5):
        print(f'run2-{i}')
        time.sleep(1)

if __name__ == '__main__':
    from multiprocessing import Process  # windon系统要把多进程包放在执行语句里面

3、通过Process创建进程
    # Process函数中必须包含一个target参数，指定创建进程的函数
    p1 = Process(target=run1)
    p2 = Process(target=run2)

4、执行进程
    p1.start()
    p2.start()

if name :
如果是在当前文件执行：name == ‘main’
如果是在其他文件中执行：name == 源文件名称

1.2 多进程的使用

• 多进程可以同时执行多个任务。

1.2.1 join( )方法

• join作用：阻塞进程
• 放在两进程之间：并行改串行，一个进程执行完成才执行另外一个进程。若放最后起不到该效果。
• 放在所有执行进程之后，是所有子进程执行完后才执行主进程。

# p1执行完才执行p2
 p1.start()
 p1.join()   
 p2.start()
 # 若放在进程后面起不到阻塞作用
 p1.start()
 p2.start()
 p1.join()  

1.2.2 获取进程编号

• 获取进程编号的目的：获取进程编号的目的是验证主进程和子进程的关系。
• os.getpid( )：获取子进程编号
• os.getppid( )：获取主进程编号

用法：直接放在进程中print获取该进程编号。

print('子进程：', os.getpid())
print('主进程：', os.getppid())

1.2.3 带有参数的进程

• 给进程传递非关键字参数，需要定义args：可以是列表和元组。
• 给进程传递关键字参数，需定义kwargs：类型是字典。
• 传的参数通过函数接收。

p1 = Process(target=run1, args=('a',),kwargs={'age':10})

1.2.4 综合代码演示

import os

def run1(name,age):
    print('run1--',name,age)
    # 获取子进程的进程编号
    print('run1--',os.getpid())
    time.sleep(2)
    # 获取主进程的进程编号
    print('主进程：',os.getppid())

def run2(name,age):
    print('run2--',name,age)
    # 获取子进程的进程编号：
    print('run2--', os.getpid())
    time.sleep(1)
    print('主进程：',os.getppid())

if __name__ == '__main__':
    from multiprocessing import Process # windon系统要把多进程包放在执行语句里面

    # 给进程传递非关键字参数，需要定义args：可以是列表和元组
    # 给进程传递关键字参数，需定义kwargs：类型是字典
    p1 = Process(target=run1, args=('a',),kwargs={'age':10})
    p2 = Process(target=run2, args=('b',), kwargs={'age':20})

    p1.start()
    p1.join()   # p1执行完才执行p2
    p2.start()

1.3 守护进程

• 作用：当主进程结束，不管子进程有没有结束，当前所有进程都结束。
• 语法：子进程对象.daemon=True
• 加了join则守护进程失去效果！

普通进程：要所有子进程结束，主进程才结束。

def run1():
    for i in range(5):
        print(f'run1-{i}')
        time.sleep(1)
def run2():
    for i in range(5):
        print(f'run2-{i}')
        time.sleep(1)

if __name__ == '__main__':
    from multiprocessing import Process # windon系统要把多进程包放在执行语句里面
    p1 = Process(target=run1)
    p2 = Process(target=run2)

    # 设置守护进程
    p1.daemon=True
    p2.daemon=True
    # 主进程，执行后不在执行子进程
    print('main')	--->最终显示结果：main

    p1.start()
    p2.start()

1.4 进程间数据共享

• 进程之间数据不是共享的。但是可通过一些方法共享数据，进程间数据共享常用的3种方法：manager管理器、queue队列、Pipe管道。

1.4.1 manager管理器

• 导入Manager包：from multiprocessing import Process, Manager
• 在调用函数内、创建进程之前定义对象：manager.对象

with Manager() as manager:
    lis = manager.list()
    dic = manager.dict()

• 代码实例：

def run1(lis,dic):
    lis.append('run1')
    dic['name1']='run1'
def run2(lis,dic):
    lis.append('run2')
    dic['age']=20

if __name__ == '__main__':
    from multiprocessing import Process, Manager
    # 实例化
    with Manager() as manager:
        lis = manager.list()
        dic = manager.dict()

        p1 = Process(target=run1,args=[lis,dic])
        p2 = Process(target=run2,args=(lis,dic))

        p1.start()
        p2.start()

        p1.join()
        p2.join()
        # p1,p2执行完才执行主进程
        print(lis,dic)	---> ['run1', 'run2'] {'name1': 'run1', 'age': '20'}

1.4.2 queue队列

• 队列：只允许在一端进行插入操作，而在另一端进行删除操作的线性表。是一种先进先出的线性表。
• 导入Queue包：from multiprocessing import Process, Queue
• 在调用函数内、创建进程之前实例化队列：q=Queue()

import time
def run1(q):
    q.put('run1')
    time.sleep(1)   # 为什么不要或者放在print后’run2‘一直无法打印出来，程序一直在运行
    print(q.get())
def run2(q):
    print(q.get())
    q.put('run2')

if __name__ == '__main__':
    from multiprocessing import Process, Queue
    # 实例化队列
    q=Queue()

    p1 = Process(target=run1,args=(q,))
    p2 = Process(target=run2,args=(q,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

如果程序中只有一个print函数，则只会打印run1。

1.4.3 管道Pipe

• 管道Pipe：一个进程发数据send()，必须由另外一个进程接收recv()。
• 导入Pipe包：from multiprocessing import Process, Pipe
• 实例化：pi1, pi2=Pipe()

import time

def run1(pi1):
    pi1.send('run1')
    time.sleep(1)
    print('该处是run2的值：',pi1.recv())	
def run2(pi2):
    print('该处是run1的值：',pi2.recv())	
    pi2.send('run2')
if __name__ == '__main__':
    from multiprocessing import Process, Pipe
    # 实例化对象
    pi1,pi2 = Pipe()

    p1 = Process(target=run1,args=(pi1,))
    p2 = Process(target=run2,args=(pi2,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()
结果：
该处是run1的值： run1
该处是run2的值： run2

1.4 进程池

• 进程池：预先创建一组子进程，当有新任务来时，系统通过 调配 该组进程中的某个 子进程 完成此任务。
• 为什么使用进程池：因为不会频繁的创建和销毁进程，节省资源。
• 进程池中一般创建多少个进程效率最高：不超过电脑中CPU核数的2倍。

1.4.1 进程池使用过程：

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

1.4.2 进程池的创建

• 主要步骤：

1. 导入Pool包：from multiprocessing import Pool
2. 创建进程池：pool = Pool(3)，Pool方法的第一个参数是初始化多少个进程（最大进程数）。
3. 调用函数：pool.apply_async(要调用的函数名)
4. 关闭进程池（必须）：pool.close()
5. 结束主进程（必须）：pool.join()，必须等待所有的请求全部执行完成之后，再结束主进程。必须放在close后。

1、导入进程池的包
import os
from multiprocessing import Pool
import time

def run1():
    print(os.getpid())
    time.sleep(1)
if __name__ == '__main__':

    2、创建一个进程池
    # Pool方法的第一个参数是初始化多少个进程
    pool = Pool(3)

    for i in range(10):
        # 参数是函数名称
        pool.apply_async(run1)

3、必须关闭进程池
    pool.close()

4、必须等待所有的请求全部执行完成之后，再结束主进程。必须放在close后
    pool.join()

1.5 多进程运行时间案例

import time
from multiprocessing import Process

def run(j):
    num = 0
    for i in range(j):
        num += i
    with open(f'{j}.txt', 'w') as fp:
        fp.write(str(num))

if __name__ == '__main__':
    start_time = time.time()
    data = [10000000, 20000000, 30000000]
    p_list = []
    for j in data:
        p = Process(target=run, args=(j,))  # 创建3个进程
        p_list.append(p)
        p.start()
    for m in p_list:    # 依次关闭3个进程
        m.join()
    end_time = time.time()
    print(end_time - start_time)

二、线程

在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。

• 线程是进程中执行代码的一个分支，每个执行分支（线程）要想工作执行代码需要cpu进行调度 ，线程是cpu调度的基本单位，每个进程至少都有一个线程（主线程）。
• 线程的作用：多线程可以完成多任务。
• Python中的多线程是伪多线程【重点】：
  由于Python解释器中存在GIL锁（全局解释器锁：防止数据错乱），所以Python中的多线程是伪多线程，即CPU不能并行执行，只能并发执行。

程序启动默认会有一个主线程，程序员自己创建的现场叫子线程。

2.1 多线程的创建

• 步骤：

1. 导入Thread包：from threading import Thread
2. 定义函数
3. 创建线程：t1=Thread(target=‘函数名’)
4. 执行线程：t1.start()
5. 关闭线程：t1.join()

1、导包
from threading import Thread

import time
2、定义函数
def run1():
    for i in range(5):
        print(f'run1-{i}')
        time.sleep(1)
def run2():
    for i in range(5):
        print(f'run2-{i}')
        time.sleep(1)

if __name__ == '__main__':

3、创建线程
    t1=Thread(target=run1)
    t2=Thread(target=run2)
4、执行线程
    t1.start()
    t2.start()

    t1.join()
    t2.join()

2.2 多线程传递参数

• 线程执行任务并传参有两种方式:

1. args：以元组或列表方式传参，一定要和参数的顺序保持一致。
2. kwargs：以字典方式传参，字典中的key一定要和参数名保持一致。

from threading import Thread
import time

def run1(name,age):
        print(name,age)
        time.sleep(1)
def run2(name,age):
        print(name,age)
        time.sleep(1)

if __name__ == '__main__':
    t1 = Thread(target=run1, args=('t1',), kwargs={'age':22})
    t2 = Thread(target=run2, args=('t2',), kwargs={'age':30})

    t1.start()
    t2.start()

    t1.join()
    t2.join()

2.3 守护线程

• 守护线程：主线程结束，不管子线程有没有结束，整个进程都结束。
• 设置守护线程的目的：是主线程退出子线程销毁，不让主线程再等待子线程去执行。
• 设置方法：方法：子线程对象.setDaemon(True)

import time

def run1(name):
    time.sleep(1)
    print(name)
def run2(name):
    time.sleep(1)
    print(name)

if __name__ == '__main__':
    from threading import Thread
    t1 = Thread(target=run1, args=('t1',))
    t2 = Thread(target=run2, args=('t2',))
    # 守护线程
    t1.setDaemon(True)
    t2.setDaemon(True)
    print('main')

    t1.start()
    t2.start()
结果：只打印主线程结果
main

2.4 线程间的数据共享

• 多线程间数据是共享的。但是会导致多线程间相同变量名的参数数据错乱。
• 解决方法：加锁，在需要连续执行的代码片段前后加锁、释放锁。

1. 导入锁Lock包：from threading import Thread, Lock
2. 实例化：lock = Lock()
3. 加锁：lock.acquire()
4. 释放锁：lock.release()

数据共享示例：

from threading import Thread

lis = []
def run1():
    lis.append('run1')
def run2():
    lis.append('run2')

if __name__ == '__main__':

    t1 = Thread(target=run1)
    t2 = Thread(target=run2)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    print(lis)	---> ['run1', 'run2']

解决多线程数据共享错乱：

from threading import Thread, Lock

lock = Lock()
a = 0
def run1():
    global a
    for i in range(1000000):
        # 加锁
        lock.acquire()
        a += 1
        # 释放锁
        lock.release()
def run2():
    global a
    for i in range(1000000):
        lock.acquire()
        a += 1
        lock.release()

if __name__ == '__main__':
    t1 = Thread(target=run1)
    t2 = Thread(target=run2)

    t1.start()
    t2.start()
    # print(a)  # 出错，未执行完成
    t1.join()
    t2.join()
    print(a)

三、进程和线程的对比

3.1 关系对比

1. 线程是依附在进程里面的，没有进程就没有线程。
2. 一个进程默认提供一条线程，进程可以创建多个线程。

3.2 区别对比

1. 进程之间不共享全局变量
2. 线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 加锁
3. 创建进程的资源开销要比创建线程的资源开销要大
4. 进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
5. 线程不能够独立执行，必须依存在进程中
6. 多进程开发比单进程多线程开发稳定性要强

3.3 优缺点对比

1. 进程优缺点:
   优点：可以用多核
   缺点：资源开销大
2. 线程优缺点:
   优点：资源开销小
   缺点：不能使用多核

3.4 使用场景【重点】

1. 计算密集型：CPU 长时间满负荷运行, 如图像处理、大数据运算、科学运算等。使用多进程
2. I/O 密集型：网络 IO, 文件 IO, 设备 IO 等。使用多线程