• 多任务 ： 操作系统可以同时运行多个任务
  • 并发 : 任务数 > cpu核数, 通过操作系统任务调度算法, 实现用多个任务在同一时间段执行(事实上只有cpu核数个在执行)
  • 并行 : 多核cpu情况下,多个任务的一些任务往往是在同一时间点执行的

在实际的场景中往往既有并发又有并行的多任务。

一、多线程

线程 ：一个进程内部的一条代码执行流程(线程)

代码默认在默认线程上执行

1. threading模块

python的thread模块是比较底层的模块,python的threading模块是对thread做了一些包装的,可以更加方便的被使用

  • 函数实现多线程
import threading
import time


def say_sorry():
    print("I am sorry")
    time.sleep(1)


if __name__ == '__main__':
    for i in range(5):
        t = threading.Thread(target=say_sorry)
        t.start()
  • 程序会等待所有的子线程结束后才结束
  • 线程数量
threading.enumerate()

2. 多线程代码封装

  • 类实现多线程
import threading
import time


class MyThread(threading.Thread):
    def run(self):
        time.sleep(1)
        print(self.name)


if __name__ == '__main__':
    for i in range(5):
        t = MyThread()
        t.start()

执行结果

Thread-3
Thread-1
Thread-2
Thread-4
Thread-5
  • 线程执行顺序
    从上面可以看出多线程程序的执行顺序是不确定的

3. 多线程-共享全局变量

在一个进程内的所有线程共享全局变量,很方便在多个线程间共享数据
缺点 : 线程是对全局变量随意修改可能造成多线程之间对全局变量的混乱(即非线程安全)

  • 线程不安全案例
import threading

g_num = 0


def work1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print(g_num)


if __name__ == '__main__':
    t1 = threading.Thread(target=work1, name="1T", args=(10000000,))
    t2 = threading.Thread(target=work1, name="2T", args=(10000000,))
    t1.start()
    t2.start()
  • 同步
    线程同步：一个操作完成后再进行下一个操作
    同步用互斥锁完成

程序中的同步相当于生活中的异步， 异步相当于生活中的同步

# 创建锁
lock = threading.Lock()
# 锁定
lock.acquire()
# 释放
lock.release()

上面线程不案例的案例可以这样解决

lock = threading.Lock()

lock.acquire()
global g_num
lock.release
  • 锁总结
  • 锁的好处:
  • 确保了某段关键代码只能由一个线程从头到尾完整地执行
  • 锁的坏处:
  • 阻止了多线程并发执行,包含锁的某段代码实际上只能以单线程模式执行,效率就大大地下降了
  • 由于可以存在多个锁,不同的线程持有不同的锁,并试图获取对方持有的锁时,可能会造成死锁
  • 死锁

A锁等待B锁先释放， B锁等待A锁先释放，将造成死锁

  • 避免死锁的方法
  • 程序设计时尽量避免
  • 添加超时时间

4. 案例：udp多线程聊天室

  • 示例
import threading
from socket import *
def send_msg(udp_socket):
    while True:
        udp_socket.sendto(input("请输入内容：").encode("utf-8"), ("127.0.0.1", 8888))
def recv_msg(udp_socket):
    while True:
        recv_msg = udp_socket.recvfrom(1024)
        print("服务器返回消息："+recv_msg[0].decode("utf-8"))
def main():
    # 1.创建socket
    udp_socket = socket(AF_INET, SOCK_DGRAM)
    udp_socket.bind(("", 9999))
	# 发送接收数据
    recv_thread = threading.Thread(target=recv_msg, args=(udp_socket,))
    recv_thread.start()
    send_msg(udp_socket)
if __name__ == '__main__':
    main()

二、多进程

1. 进程介绍

程序 : 例如xxx.py这是程序,是一个静态的
**进程 **: 一个程序运行起来后,代码+用到的资源称之为进程,它是操作系统分配资源的基本单元。

  • 就绪态 : 运行的条件都已经慢去,正在等在cpu执行
  • 执行态 : cpu正在执行其功能
  • 等待态 : 等待某些条件满足,例如一个程序sleep了,此时就处于等待态

2. 创建进程-multiprocessing

  • 函数创建子进程
import time
from multiprocessing import Process


def run_proc(name, age, **kwargs):
    time.sleep(1)
    print(1)


if __name__ == '__main__':
    for i in range(2):
        p = Process(target=run_proc, args=("test", 18), kwargs={"m": 20})
        p.start()

3. Process语法结构如下:

Process([group[,target[,name[,args[,kwargs]]]]])

  • target:如果传递了函数的引用,可以任务这个子进程就执行这里的代码
  • args:给target指定的函数传递的参数,以元组的方式传递
  • kwargs:给target指定的函数传递命名参数
  • name:给进程设定一个名字,可以不设定
  • group:指定进程组,大多数情况下用不到

Process创建的实例对象的常用方法:

  • start():启动子进程实例(创建子进程)
  • is_alive():判断进程子进程是否还在活着
  • join([timeout]):是否等待子进程执行结束,或等待多少秒
  • terminate():不管任务是否完成,立即终止子进程

Process创建的实例对象的常用属性:

  • name:当前进程的别名,默认为Process-N,N为从1开始递增的整数
  • pid:当前进程的pid(进程号)

4. 进程间不共享全局变量

  • 示例
import time
from multiprocessing import Process


nums = [11, 22]


def run_proc():
    nums.append(1)
    time.sleep(3)
    print(nums)


if __name__ == '__main__':
    p = Process(target=run_proc)
    p.start()
    p.join()

    p2 = Process(target=run_proc)
    p2.start()

结果为

[11, 22, 1]
[11, 22, 1]

三、进程、线程对比

进程 ：能够完成多任务,比如在一台电脑上能够同时运行多个QQ
线程 ：能够完成多任务,比如一个QQ中的多个聊天窗口

  • 定义的不同
  • 进程 ：系统进行资源分配和调度的一个独立单位.
  • 线程 ：是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位
    线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和
    栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
  • 区别
  • 一个程序至少有一个进程,一个进程至少有一个线程.
  • 线程的划分尺度小于进程(资源比进程少),使得多线程程序的并发性高。
  • 进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率

线线程不能够独立执行,必须依存在进程中
可以将进程理解为工厂中的一条流水线,而其中的线程就是这个流水线上的工人

  • 优缺点
    线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源的管理和保护;而进程正相反。

四、进程间通信

1. Queue

可以使用multiprocessing模块的Queue实现多进程之间的数据传递

Queue本身是一个消息列队程序

  • Queue的方法
  • q=Queue(5) # 5为最大接收消息数量
  • Queue.qsize() : 返回当前队列包含的消息数量;
  • Queue.empty() : 如果队列为空,返回True,反之False;
  • Queue.full() : 如果队列满了,返回True,反之False;
  • Queue.get([block[,timeout]]) : 获取队列中的一条消息,然后将其从列队中移除
  • block默认值为True，无timeout时, 消息列队如果为空,此时程序将被阻塞(停在读取状态),直到从消息列队读到消息为止
  • 如果设置了timeout,则会等待timeout秒,若还没读取到任何消息,则抛出"Queue.Empty"异常;
  • block值为False,消息列队如果为空,则会立刻抛出"Queue.Empty"异常;
  • Queue.get_nowait() : 相当Queue.get(False);
  • Queue.put(item,[block[,timeout]]) : 将item消息写入队列,block默认值为True;
  • Queue.put_nowait(item) : 相当Queue.put(item,False);
  • Queue示例
from multiprocessing import Queue

q = Queue(2)

if not q.full():
    q.put_nowait("info")
    
if not q.empty():
    q.get_nowait()

2. Queue在进程间的通信

  • 示例
from multiprocessing import Queue, Process


def write(q):
    while True:
        if not q.full():
            q.put_nowait("info")


def read(q):
    while True:
        if not q.empty():
            print(q.get_nowait())


def main():
    # 1.父进程创建Queue并传给子进程
    q = Queue(3)  # type:Queue
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))

    # 2.写入的子进程写入数据
    pw.start()
    pw.join()

    # 3.读取的子进程读取数据
    pr.start()
    pr.join()

    # 4.结束
    print("over")


if __name__ == '__main__':
    main()

五、进程池Pool

multiprocessing中的Pool方法一次性动态成生多个进程

  • Pool(5)
  • 初始化5个进程
  • 新请求提交到Pool时，若Pool没满，创建新进程执行该请求
  • 若Pool已达最大值，请求等待，直到池中有进程结束，才会用之前的进程来执行新的任务
  • multiprocessing.Pool常用函数解析
  • apply_async(func[,args[,kwds]]) : 使用非阻塞方式调用func(并行执行,堵塞方式必须等待上一个进程退出才能执行下一个进程),args为传递给func的参数列表,kwds为传递给func的关键字参数列表;
  • close() : 关闭Pool,使其不再接受新的任务;
  • terminate() : 不管任务是否完成,立即终止;
  • join() : 主进程阻塞,等待子进程的退出, 必须在close或terminate之后使用;
  • 示例
from multiprocessing import Pool


def work(msg):
    pass


po = Pool(3)
for i in range(3):
    po.apply_async(work, (i,))


po.close()  # 关闭进程池,关闭后po不再接收新的请求
po.join()  # 等待po中所有子进程执行完成,必须放在close语句之后
  • 进程池中的Queue

使用Pool创建进程，使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()

from multiprocessing import Manager
Manager().Queue(3)

案例：copy功能

  • 示例
import os
from multiprocessing import Process, Queue


def copy_file(file_path, new_dir_path, q):
    if os.path.isdir(file_path):
        os.mkdir(new_dir_path)
    else:
        content = None
        try:
            with open(file_path, "rb") as fr:
                content = fr.read()
        except Exception as e:
            print(e)
        try:
            with open(new_dir_path, "wb") as fw:
                fw.write(content)
        except Exception as e:
            print(e)
    if not q.full():
        q.put_nowait(file_path)


file_path_list = []
dir_path_list = []


def get_file_path(path):
    if os.path.isfile(path):
        file_path_list.append(path)
    else:
        dir_path_list.append(path)
        path_list = os.listdir(path)
        for new_path in path_list:
            get_file_path(path + "/" + new_path)
    return file_path_list, dir_path_list


def main():
    # 消息对列用于显示进度
    q = Queue(1000)

    # 1.获取copy的文件夹
    dir_path = input("请输入要copy的文件夹绝对路径：")
    dir_path_back = dir_path + "[backup]"

    # 2.递归取出每个空文件夹及文件路径
    get_file_path(dir_path)

    # 3.分别copy文件及空文件夹  到  新的文件夹
    for empty_file_path in dir_path_list:
        new_dir_path = dir_path_back + empty_file_path[dir_path_back.find("["):]
        copy_file(empty_file_path, new_dir_path, q)

    for file_path in file_path_list:
        # /home/test[back]  /home/test/t.txt  --> /home/test[back]/t.txt
        new_dir_path = dir_path_back + file_path[dir_path_back.find("["):]
        # copy_file(file_path, new_dir_path, q)
        p = Process(target=copy_file, args=(file_path, new_dir_path, q))
        p.start()

    # 4.显示进度
    count = 0
    sum = len(file_path_list) + len(dir_path_list)
    while True:
        if not q.empty():
            q.get_nowait()
            count += 1
        print("进度为%.2f%%" % (count/sum*100))
        if count/sum == 1:
            break


if __name__ == '__main__':
    main()

六、迭代器

1. 可迭代对象

  • 可迭代对象

可迭代对象(Iterable) ：可以通过for…in…这类语句迭代读取一条数据供我们使用的对象

  • 如何判断一个对象是否可以迭代
    isinstance()判断一个对象是否是Iterable对象
# 可迭代对象有：[], (), {}, "abc"
isinstance({}, Iterable)  # 判断一个对象是否是可迭代对象
  • 可迭代对象的本质
  • 迭代器：每迭代一次，for…in…都返回下一条数据，在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，我们把这个“人”称为迭代器(Iterator)。
  • 可迭代对象的本质 ：可以向我们提供一个这样的中间“人”即迭代器帮我们对其进行迭代遍历
  • 可迭代对象的实现 ：通过 __iter__方法向我们提供一个迭代器，那么也就是说,一个具备__iter__ 方法的对象,就是一个可迭代对象。
  • 可迭代对象的实现
from collections import Iterable


class MyList(object):
    def __init__(self):
        self.container = []

    def add(self, item):
        self.container.append(item)

    def __iter__(self):
        pass


my_list = MyList()
print(isinstance(my_list, Iterable))  # True

2. 迭代器

一个实现了 __iter__方法和__next__ 方法的对象,就是迭代器。

迭代器 : 帮助记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。

实际上 ，在使用next()函数的时候,调用的就是迭代器对象的 __next__ 方法(Python3中是对象的 __next__方法,Python2中是对象的next()方法)

构造一个迭代器 ， 就要实现它的__next__方法。python要求迭代器本身也是可迭代的,所以我们还要为迭代器实现 __iter__方法，,而 __iter__ 方法要返回一个迭代器,迭代器自身正是一个迭代器,所以迭代器的 __iter__方法返回自身即可。

  • iter()

iter()函数可获取可迭代对象的迭代器

from collections import Iterator

print(isinstance([], Iterator))  # False
print(isinstance(iter([]), Iterator))  # True
print(isinstance(iter("abc"), Iterator))  # True
  • next()

对获取到的迭代器不断使用next()获取下一条数据

list_iter = iter([1, 2])
next(list_iter)
# 当next取不到数据时，抛出StopIteration异常

3. for … in … 本质

iter() --获取–> 可迭代对象Iterable的迭代器 --> next()获取值赋给item --> 异常StopIteration结束循环

4. 应用

迭代器通过next()函数的调用来返回下一个数据值 --> 不用再将所有要迭代的数据都一次性缓存下来供后续依次读取,这样可以节省大量的存储(内存)空间

  • 示例
from collections import Iterable


class FibIterator(object):
    def __init__(self, n):
        self.n = n
        self.current = 0
        self.num1 = 0
        self.num2 = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.n:
            self.num1, self.num2 = self.num2, self.num1+self.num2
            self.current += 1
            return self.num1
        else:
            raise StopIteration


fib = FibIterator(10)
for num in fib:
    print(num, end=" ")

七、生成器

1. 生成器介绍

生成器是一类特殊的迭代器

利用迭代器可以在每次迭代获取数据(通过next()方法)时按照特定的规律进行生成.

但是我们在实现一个迭代器时,关于当前迭代到的状态需要我们自己记录,进而才能根据当前状态生成下一个数据

为了达到记录当前状态,并配合next()函数进行迭代使用,我们可以采用更简便的语法,即生成器(generator)

2. 创建生成器

  • [] --> () : 把一个列表生成式的[]改成()
G = (x*2 for x in range(5))

对于生成器G, 可以按照迭代器的使用方法来使用,即可以通过next()函数、for循环、list()等方法使用。

next(G)
for x in G:
    print(x)
  • 方法二：yield

只要在def中有yield关键字的就称为生成器

def fib(n):
    current = 0
    num1, num2 = 0, 1
    while current < n:
        num = num1
        num1, num2 = num2, num1 + num2
        current += 1
        yield num  # yield使fib函数成为一个生成器而不再是一个函数
    return "done"


F = fib(5)
print(next(F))
for f in F:
    print(f)

获取生成器中return的值

返回值包含在StopIteration的value中

F = fib(5)
while True:
    try:
        x = next(F)
    except StopIteration as e:
        print(e.value)
        break

3. 使用send方法

  • send唤醒生成器
...
temp = yield num
...

next(F)  # next(F) 等价于 F.send(None)
F.send("python")  # 此时的temp就为"python"
# 正确的解释是next和send函数在执行完yield后暂停执行(断点)，即将生成器函数挂起。并将yield后的值返回
# 使用send时在断点处传入一个“附加数据”，temp用来接收这个附加数据

八、协程

1. 协程介绍

  • 协程,又称微线程,纤程
  • 它是一个自带CPU上下文的执行单元
  • 例如： 可以在任何地方保存当前函数的一些临时变量等信息,然后切换到另外一个函数中执行并且切换次数及时机由开发者确定
  • 协程和线程差异
    线程切换从系统层面远不止保存和恢复CPU上下文这么简单。操作系统为了程序运行的高效性每个线程都有自己缓存Cache等等数据,操作系统还会帮你做这些数据的恢复操作。所以线程的切换非常耗性能。
    但是协程的切换只是单纯的操作CPU的上下文,所以一秒钟切换个上百万次系统都抗的住。

2. 协程的实现

  • 协程的简单实现
def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        r = '200 OK'

def produce(c):
    c.send(None)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()

c = consumer()
produce(c)

用yield实现协程

传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁

协程生产消费模型生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高

  • gevent

其原理是当一个greenlet遇到IO操作时,比如访问网络,就自动切换到其他的greenlet,等到IO操作完成,再在适当的时候切换回来继续执行。
由于IO操作非常耗时,经常使程序处于等待状态,有了gevent为我们自动切换协程,就保证总有greenlet在运行,而不是等待IO

pip3 install gevent
import gevent


def f(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        gevent.sleep(1)


g1 = gevent.spawn(f, 2)
g2 = gevent.spawn(f, 2)
g1.join()
g2.join()
# 运行结果为
<Greenlet at 0x7fc4eca68448: f(5)> 0
<Greenlet at 0x7fc4eca68648: f(5)> 0
<Greenlet at 0x7fc4eca68448: f(5)> 1
<Greenlet at 0x7fc4eca68648: f(5)> 1

3. 给程序打补丁

  • 示例

将程序中用到的耗时操作的代码,换为gevent中自己实现的模块

import random
import time
from gevent import monkey
import gevent

monkey.patch_all()  # 猴子补丁


def work(work_name):
    for i in range(2):
        time.sleep(random.random())
        print(work_name)


gevent.joinall([
    gevent.spawn(work, "work1"),
    gevent.spawn(work, "work2")
])

4. 进程、线程、协程总结

  1. 进程是资源分配的单位
  2. 线程是操作系统调度的单位
  3. 进程切换需要的资源很最大,效率很低
  4. 线程切换需要的资源一般,效率一般
  5. 协程切换任务资源很小,效率高
  6. 多进程、多线程根据cpu核数不一样可能是并行的也可能是并发的。协程的本质就是使用当前进程， 在不同的函数代码中切换执行,可以理解为并行。协程是一个用户层面的概念,不同协程的模型实现可能是单线程也可能是多线程。