【python】第一模块 步骤五 第二课、Python多线程

第二课、Python多线程

一、课程介绍

 　　1.1 课程概要

 　　章节概要

• 进程、线程与并发
• 对多核的利用
• 实现一个线程
• 线程之间的通信
• 线程的调度和优化

 　　1.2 为什么要学习多线程

 　　（线程）使用场景

• 快速高效的爬虫程序
• 多用户同时访问的web服务
• 电商秒杀、抢购活动
• 物联网传感器监控服务器

 　　线程vs进程vs协程

　　重要性

• 跳槽、面试、决定薪资高度
• 解决“效率”问题
• Python的GIL导致的系列问题
• 通常会混合使用（多进程+协程）

 

二、线程的实现及相关操作

 　　2.1 线程的介绍

　　进程

• 是一个执行中的程序
• 每个进程都拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据
• 操作系统管理及上所有进程的执行，并为这些进程合理的分配时间
• 进程也可通过派生（fork或spawn）新的进程来执行其他任务

　　线程

• 在同一个进程下执行，并共享相同的上下文
• 一个进程中的各个线程与主线程共享同一片数据空间
• 线程包括开始、执行顺序和结束三部分
• 它可以被抢占（中断）和临时挂起（也成为睡眠）————让步
• 一般是以并发方式执行

　　并发

• 是一种属性——程序、算法或问题的属性
• 并行是指并发问题的可能方法之一
• 如果两个事件互不影响，则两个事件是并发的

 

 　　2.2 对多核的利用及GIL概念

　　对多核的利用

• 单核CPU系统中，不存在真正的并发
• GIL——全局解释器锁
• GIL只是强制在任何时候只有一个线程可以执行Python代码
• I/O密集型应用与CPU密集型应用

　　GIL执行顺序

1. 设置GIL
2. 切换进一个线程去运行
3. 执行下面操作之一：
   1. 指定数量的字节码指令
   2. 线程主动让出控制权（可以调用time.sleep(0)来完成）
4. 把线程设置回睡眠状态（切换出线程）
5. 解锁GIL
6. 重复上述步骤

 

 　　2.3 线程的两种实现方式

　　实现一个线程

• 用threading模块代替thread模块
• 用threading.Tread创建线程
• start()启动线程
• jion()挂起线程

　　threading模块的对象

对象	描述
Thread	表示一个执行线程的对象
Lock	锁原语对象（和thread模块中的锁一样）
RLock	可重入锁对象，使单一线程可以（再次）获得已持有的锁（递归锁）
Condition	条件变量对象，使得一个线程等待另一个线程满足特定的“条件”，比如改变状态或某个数据值
Event	条件变量的通用版本，任意数量的线程等待某个事件的发生，在该事件发生后所有线程将被激活
Semaphore	为线程间共享的有限资源提供了一个“计数器”，如果没有可用资源时会被阻塞
BoundedSemap hore	与Semaphore相似，不过它不允许超过初始值
Timer	与Thread相似，不过它要再运行前等待一段时间
Barrier	创建一个”障碍“，必须达到指定数量的线程后才可以继续

 

 

 

 

 

 

 

　　Thread对象数据属性

属性	描述
name	线程名
ident	线程的标识符
daemon	布尔标志，表示这个线程是否是守护线程

 

 

 

　　Thread对象方法

属性	描述
__init__()	实例化一个线程对象，需要有一个可调用的target，以及其参数args或kwargs
start()	开始执行该线程
run()	定义线程功能的方法（通常在子类中被应用开发者重写）
jion(timeout=None)	直至启动的线程终止之前一直挂起；除非给出了timeout（秒），否则会一直阻塞
getName()	返回线程名
setName(name)	设定线程名
isAlivel/is_alive()	布尔标志，表示这个线程是否还存活
isDaemon()	如果是守护线程，则返回True；否则，返回False
setDaemon()	把线程的守护标志设定为布尔值daemonic（必须在线程start（）之前调用）

 

 

 

 

 

 

 

　　实现一个线程

import threading
import time


def loop():
    """ 新的线程执行的代码 """
    n = 0
    while n < 5:
        print(n)
        now_thread = threading.current_thread()
        print('now thread name : {0}'.format(now_thread.name))
        time.sleep(1)
        n += 1


def use_thread():
    """ 使用线程来实现 """
    # 当前正在执行的线程名称
    now_thread = threading.current_thread()
    print('now thread name : {0}'.format(now_thread))
    t = threading.Thread(target=loop, name='loop_thread')
    # 启动线程
    t.start()
    # 挂起线程
    t.join()


if __name__ =='__main__':
    use_thread()

import threading
import time


class LoopThread(threading.Thread):
    """ 自定义线程 """

    n = 0

    def run(self):
        while self.n < 5:
            print(self.n)
            now_thread = threading.current_thread()
            print('now thread name : {0}'.format(now_thread.name))
            time.sleep(1)
            self.n += 1


if __name__ == '__main__':
    # 当前正在执行的线程名称
    now_thread = threading.current_thread()
    print('now thread name : {0}'.format(now_thread.name))
    t = LoopThread(name='loop_thread_oop')
    t.start()
    t.join()

 

　　2.4 多线程并发问题

 　　实现多个线程

• 最后为什么不是0？

import threading
import time



# 我的银行账户
balance = 0


def change_it(n):
    """改变我的余额"""
    global balance
    balance = balance + n
    time.sleep(2)
    balance = balance - n
    time.sleep(1)
    print('--------->{0}'.format(n))


class ChangeBalanceThread(threading.Thread):
    """
    改变银行余额的线程
    """

    def __init__(self, num, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.num = num

    def run(self):
        for i in range(1000):
            change_it(self.num)


if __name__ == '__main__':
    t1 = ChangeBalanceThread(5)
    t2 = ChangeBalanceThread(8)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print('the last: {0}'.format(balance))

 

　　2.5 多线程中的锁

　　多线程中的锁实现

• Lock()
• Rlock()
• Condition()

import threading
import time


# 获得一把锁
my_lock = threading.Lock()
your_lock = threading.RLock()

# 我的银行账户
balance = 0


def change_it(n):
    """ 改变我的余额 """
    global balance

    # 方式一，使用with
    with your_lock:
        balance = balance + n
        time.sleep(2)
        balance = balance - n
        time.sleep(1)
        print('-N---> {0}; balance: {1}'.format(n, balance))

    # 方式二
    # try:
    #     print('start lock')
    #     # 添加锁
    #     your_lock.acquire()
    #     print('locked one ')
    #     # 资源已经被锁住了，不能重复锁定, 产生死锁
    #     your_lock.acquire()
    #     print('locked two')
    #     balance = balance + n
    #     time.sleep(2)
    #     balance = balance - n
    #     time.sleep(1)
    #     print('-N---> {0}; balance: {1}'.format(n, balance))
    # finally:
    #     # 释放掉锁
    #     your_lock.release()
    #     your_lock.release()


class ChangeBalanceThread(threading.Thread):
    """
    改变银行余额的线程
    """

    def __init__(self, num, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.num = num

    def run(self):
        for i in range(100):
            change_it(self.num)


if __name__ == '__main__':
    t1 = ChangeBalanceThread(5)
    t2 = ChangeBalanceThread(8)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print('the last: {0}'.format(balance))

 

　　2.6 线程的调度和优化

　　线程的调度和优化

import time
import threading
from concurrent.futures import ThreadPoolExecutor
from multiprocessing.dummy import Pool


def run(n):
    """ 线程要做的事情 """
    time.sleep(2)
    print(threading.current_thread().name, n)


def main():
    """ 使用传统的方法来做任务 """
    t1 = time.time()
    for n in range(100):
        run(n)
    print(time.time() - t1)


def main_use_thread():
    """ 使用线程优化任务 """
    # 资源有限，最多只能跑10个线程
    t1 = time.time()
    ls = []
    for count in range(10):
        for i in range(10):
            t = threading.Thread(target=run, args=(i,))
            ls.append(t)
            t.start()

        for l in ls:
            l.join()
    print(time.time() - t1)


def main_use_pool():
    """ 使用线程池来优化 """
    t1 = time.time()
    n_list = range(100)
    pool = Pool(10)
    pool.map(run, n_list)
    pool.close()
    pool.join()
    print(time.time() - t1)


def main_use_executor():
    """ 使用 ThreadPoolExecutor 来优化"""
    t1 = time.time()
    n_list = range(100)
    with ThreadPoolExecutor(max_workers=10) as executor:
        executor.map(run, n_list)
    print(time.time() - t1)


if __name__ == '__main__':
    # main()
    # main_use_thread()
    # main_use_pool()
    main_use_executor()

 

三、进程介绍

　　3.1 进程介绍

　　进程

• 是一个执行中的程序
• 每个进程都拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据
• 操作系统管理其上所有进程的执行，并为这些进程合理的分配时间
• 进程也可通过派生（fork或spawn）新的进程来执行其他任务

　　章节概要

• 进程模块介绍
• 进程的实现
• 进程之间的通信
• 使用进程池

　　进程模块介绍

• 我们使用multiprocessing实现多进程代码
• 用multiprocessing.Process创建进程
• start()启动进程
• join()挂起进程
• os.getpid()获得进程的ID

 

　　3.2 进程的实现

　　进程的实现

import os
import time
from multiprocessing import Process


def do_sth(name):
    """
    进程要做的事情
    :param name: str 进程的名称
    """
    print('进程的名称：{0}， pid: {1}'.format(name, os.getpid()))
    time.sleep(150)
    print('进程要做的事情')


class MyProcess(Process):

    def __init__(self, name, *args, **kwargs):
        self.my_name = name
        # print(self.name)
        super().__init__(*args, **kwargs)
        print(self.name)

    def run(self):
        print('MyProcess进程的名称：{0}， pid: {1}'.format(
            self.my_name, os.getpid()))
        time.sleep(150)
        print('MyProcess进程要做的事情')


if __name__ == '__main__':
    # p = Process(target=do_sth, args=('my process', ))
    p = MyProcess('my process class')
    # 启动进程
    p.start()
    # 挂起进程
    p.join()

 

　　3.3 进程之间的通信

　　进程之间的通信

• 通过Queue、Pipes等实现进程之间的通信

from multiprocessing import Process, Queue, current_process

import random
import time


class WriteProcess(Process):
    """ 写的进程 """
    def __init__(self, q, *args, **kwargs):
        self.q = q
        super().__init__(*args, **kwargs)

    def run(self):
        """ 实现进程的业务逻辑 """
        # 要写的内容
        ls = (
            "第一行内容",
            "第2行内容",
            "第3行内容",
            "第4行内容",
        )
        for line in ls:
            print('写入内容: {0} - {1}'.format(line, current_process().name))
            self.q.put(line)
            # 每写入一次，休息1-5秒
            time.sleep(random.randint(1, 5))


class ReadProcess(Process):
    """ 读取内容进程 """
    def __init__(self, q, *args, **kwargs):
        self.q = q
        super().__init__(*args, **kwargs)

    def run(self):
        while True:
            content = self.q.get()
            print('读取到的内容：{0} - {1}'.format(content, self.name))


if __name__ == '__main__':
    # 通过Queue共享数据
    q = Queue()
    # 写入内容的进程
    t_write = WriteProcess(q)
    t_write.start()
    # 读取进程启动
    t_read = ReadProcess(q)
    t_read.start()

    t_write.join()
    # t_read.join()

    # 因为读的进程是死循环，无法等待其结束，只能强制终止
    t_read.terminate()

 

　　3.4 多进程中的锁

 　　多进程中的锁

 

• Lock()
• Rlock()
• Condition()

import random
from multiprocessing import Process, Lock, RLock

import time


class WriteProcess(Process):
    """ 写入文件 """

    def __init__(self, file_name, num, lock, *args, **kwargs):
        # 文件的名称
        self.file_name = file_name
        self.num = num
        # 锁对象
        self.lock = lock
        super().__init__(*args, **kwargs)

    def run(self):
        """ 写入文件的主要业务逻辑 """
        with self.lock:
        # try:
        #     # 添加锁
        #     self.lock.acquire()
        #     print('locked')
        #     self.lock.acquire()
        #     print('relocked')
            for i in range(5):
                content = '现在是： {0} : {1} - {2} \n'.format(
                    self.name,
                    self.pid,
                    self.num
                )
                with open(self.file_name, 'a+', encoding='utf-8') as f:
                    f.write(content)
                    time.sleep(random.randint(1, 5))
                    print(content)
        # finally:
        #     # 释放锁
        #     self.lock.release()
        #     self.lock.release()


if __name__ == '__main__':
    file_name = 'test.txt'
    # 锁的对象
    lock = RLock()
    for x in range(5):
        p = WriteProcess(file_name, x, lock)
        p.start()

 

　　3.5 使用进程池

 　　使用进程池

import random
from multiprocessing import current_process, Pool

import time


def run(file_name, num):
    """
    进程执行的业务逻辑
    往文件中写入数据
    :param file_name: str 文件名称
    :param num: int 写入的数字
    :return: str 写入的结果
    """
    with open(file_name, 'a+', encoding='utf-8') as f:
        # 当前的进程
        now_process = current_process()
        # 写入的内容
        conent = '{0} - {1}- {2}'.format(
            now_process.name,
            now_process.pid,
            num
        )
        f.write(conent)
        f.write('\n')
        # 写完之后随机休息1-5秒
        time.sleep(random.randint(1, 5))
        print(conent)
    return 'ok'


if __name__ == '__main__':
    file_name = 'test_pool.txt'
    # 进程池
    pool = Pool(2)
    rest_list = []
    for i in range(20):
        # 同步添加任务
        # rest = pool.apply(run, args=(file_name, i))
        rest = pool.apply_async(run, args=(file_name, i))
        rest_list.append(rest)
        print('{0}--- {1}'.format(i, rest))
    # 关闭池子
    pool.close()
    pool.join()
    # 查看异步执行的结果
    print(rest_list[0].get())

 

四、协程的实现及通信

　　4.1 协程介绍

　　章节概要

• 协程介绍
• 协程的实现
• 协程之间的通信

　　协程介绍

• 协程就是协同多任务
• 协程在一个进程或者是一个线程中执行
• 不需要锁机制
• 对多核CPU的利用——多进程+协程

 

　　4.2 协程的实现

　　协程的实现

• python3.5以前
  • 使用生成器（yield）来实现

def count_down(n):
    """ 倒计时效果 """
    while n > 0:
        yield n
        n -= 1


def yield_test():
    """ 实现协程函数 """
    while True:
        n = (yield )
        print(n)


if __name__ == '__main__':
    # rest = count_down(5)
    # print(next(rest))
    # print(next(rest))
    # print(next(rest))
    # print(next(rest))
    # print(next(rest))
    rest = yield_test()
    next(rest)
    rest.send('6666')
    rest.send('6666')

• python3.5以后
  • 使用async和await关键字实现

　　async关键字

• 定义特殊函数

　　　　async def async_f():

　　　　　　pass

• 当被调用时，不执行里面的代码，而是返回一个协程对象
• 在事件循环中调度其执行前，协程对象不执行任何操作

　　await关键字

• 等待协程执行完成
• 当遇到阻塞调用的函数的时候，使用await方法将协程的控制权让出，以便loop调用其他的协程

　　asyncio模块

• get_event_loop()获得事件循环队列
• run_until_complete()注册任务到队列
• 在事件循环中调度其执行前，协程对象不执行任何操作
• asyncio模块用于事件循环

import asyncio


async def do_sth(x):
    """ 定义协程函数 """
    print('等待中: {0}'.format(x))
    await asyncio.sleep(x)

# 判断是否为协程函数
print(asyncio.iscoroutinefunction(do_sth))

coroutine = do_sth(5)
# 事件的循环队列
loop = asyncio.get_event_loop()
# 注册任务
task = loop.create_task(coroutine)
print(task)
# 等待协程任务执行结束
loop.run_until_complete(task)
print(task)

 

　　4.3 协程通信之嵌套调用

　　协程之间的数据通信

• 嵌套调用

import asyncio


async def compute(x, y):
    print('计算x +y => {0}+{1}'.format(x, y))
    await asyncio.sleep(3)
    return x + y


async def get_sum(x, y):
    rest = await compute(x, y)
    print('{0} + {1} = {2}'.format(x, y, rest))

# 拿到事件循环
loop = asyncio.get_event_loop()
loop.run_until_complete(get_sum(1, 2))
loop.close()

 

　　4.4 协程通信之队列

　　协程之间的数据通信

• 队列

# 1. 定义一个队列
# 2. 让两个协程来进行通信
# 3. 让其中一个协程往队列中写入数据
# 4. 让另一个协程从队列中删除数据

import asyncio
import random


async def add(store, name):
    """
    写入数据到队列
    :param store: 队列的对象
    :return:
    """
    for i in range(5):
        # 往队列中添加数字
        num = '{0} - {1}'.format(name, i)
        await asyncio.sleep(random.randint(1, 5))
        await store.put(i)
        print('{2} add one ... {0}, size: {1}'.format(
            num, store.qsize(), name))


async def reduce(store):
    """
    从队列中删除数据
    :param store:
    :return:
    """
    for i in range(10):
        rest = await store.get()
        print(' reduce one.. {0}, size: {1}'.format(rest, store.qsize()))


if __name__ == '__main__':
    # 准备一个队列
    store = asyncio.Queue(maxsize=5)
    a1 = add(store, 'a1')
    a2 = add(store, 'a2')
    r1 = reduce(store)

    # 添加到事件队列
    loop = asyncio.get_event_loop()
    loop.run_until_complete(asyncio.gather(a1, a2, r1))
    loop.close()