python 多任务_python多任务--线程

一、基本概念

什么是线程

线程(Thread)也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。

并发和并行

并发：

指的是任务数多于cpu核数，通过操作系统的任务调度算法，实现用多个任务“一起”执行(实际上总有一些任务不在执行，为交替执行的状态，因为切换任务的速度相当快，看上去一起执行而已)

特点

微观角度：所有的并发处理都有排队等候，唤醒，执行等这样的步骤，在微观上他们都是序列被处理的，如果是同一时刻到达的请求(或线程)也会根据优先级的不同，而先后进入队列排队等候执行。

宏观角度：多个几乎同时到达的请求(或线程)在宏观上看就像是同时在被处理。

image.png

并行：

指的是任务数小于等于cpu核数，即任务真的是一起执行的

特点

同一时刻发生，同时执行。

不存在像并发那样竞争，等待的概念。

image.png

同步和异步

同步(synchronous)： 所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。

简言之，要么成功都成功，失败都失败，两个任务的状态可以保持一致。

异步(asynchronous)：所谓异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。

为什么要使用多线程？

线程在程序中是独立的、并发的执行流。与分隔的进程相比，进程中线程之间的隔离程度要小，它们共享内存、文件句柄和其他进程应有的状态。

因为线程的划分尺度小于进程，使得多线程程序的并发性高。进程在执行过程之中拥有独立的内存单元，而多个线程共享内存，从而极大的提升了程序的运行效率。

线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性，多个线程共享一个进程的虚拟空间。线程的共享环境包括进程代码段、进程的共有数据等，利用这些共享的数据，线程之间很容易实现通信。

操作系统在创建进程时，必须为改进程分配独立的内存空间，并分配大量的相关资源，但创建线程则简单得多。因此，使用多线程来实现并发比使用多进程的性能高得要多。

二、线程实现

threading模块

import time

import datetime

from threading import Thread

# Thread类可以用来创建线程对象

# target:指定执行线程执行的任务(任务函数)

# args:kwargs: 接收任务函数的参数

# name:指定线程的名字

def work1(name):

for i in range(4):

time.sleep(1)

print(f'{name}浇花的第{i + 1}秒')

def work2(name):

for i in range(3):

time.sleep(1)

print(f'{name}打墙的第{i + 1}秒')

# 创建2个线程

t1 = Thread(target=work1, args=('小狼',), name="线程一")

t2 = Thread(target=work2, kwargs={"name": "liang"}, name='线程二')

# 启动线程 ：异步执行的状态

begin_time = datetime.datetime.now().strftime('%H:%M:%S.%f')

print("begin_time:",begin_time)

t1.start()

t2.start()

t1.join() # 默认等待子线程1执行结束

t2.join() # 默认等待子线程2执行结束

end_time = datetime.datetime.now().strftime('%H:%M:%S.%f')

print("end_time:",end_time)

# 主线程等待子线程执行结束之后再往下执行

print("执行结束")

#输出

begin_time: 14:45:15.724900

liang打墙的第1秒

小狼浇花的第1秒

小狼浇花的第2秒

liang打墙的第2秒

liang打墙的第3秒

小狼浇花的第3秒

小狼浇花的第4秒

end_time: 14:45:19.729378

执行结束

可以看到，如果两个任务单线程分别执行，则会消耗7秒的时间，而运用多线程实现多个任务，耗费的总时间不是多个任务时间之和，而是单个运行时间最长的任务(4s)。

自定义线程

继承threading.Thread来自定义线程类，其本质是重构Thread类中的run方法，同时执行多个相同任务，就是创建多次线程对象

import time

from threading import Thread

"""

通过线程类的形式来实现多线程

"""

class MyThread(Thread):

"""自定义的线程类"""

def __init__(self, name):

super().__init__()

self.name = name

def run(self):

"""线程执行的任务函数"""

for i in range(4):

time.sleep(1)

print(f'{self.name}浇花的第{i + 1}秒')

m = MyThread('小狼')

m2 = MyThread('liang')

m.start()

m2.start()

m.join()

m2.join()

print('执行结束')

#输入

liang浇花的第1秒

小狼浇花的第1秒

liang浇花的第2秒

小狼浇花的第2秒

liang浇花的第3秒

小狼浇花的第3秒

小狼浇花的第4秒

liang浇花的第4秒

执行结束

三、多线程特点

守护线程

里使用setDaemon(True)把所有的子线程都变成了主线程的守护线程，因此当主进程结束后，子线程也会随之结束。所以当主线程结束后，整个程序就退出了。

import time

from threading import Thread

"""

通过线程类的形式来实现多线程

"""

class MyThread(Thread):

"""自定义的线程类"""

def __init__(self, name):

super().__init__()

self.name = name

def run(self):

"""线程执行的任务函数"""

for i in range(4):

time.sleep(1)

print(f'{self.name}浇花的第{i + 1}秒')

m = MyThread('小狼')

m2 = MyThread('liang')

m.setDaemon(True)

m2.setDaemon(True)

m.start()

m2.start()

我们可以发现，设置守护线程之后，当主线程结束时，子线程也将立即结束，不再执行。

主线程等待子线程结束

为了让守护线程执行结束之后，主线程再结束，我们可以使用join方法，让主线程等待子线程执行。

#此处自定义线程类代码与之前一致，省略

m = MyThread('小狼')

m2 = MyThread('liang')

m.start()

m2.start()

m.join()

m2.join()

time.sleep(2.5)

print('执行结束')

多线程共享全局变量

线程是进程的执行单元，进程是系统分配资源的最小单位，所以在同一个进程中的多线程是共享资源的。

n = 0

def work1():

global n

for i in range(10):

n += 1

def work2():

global n

for i in range(10):

n += 1

t1 = Thread(target=work1)

t2 = Thread(target=work2)

# 启动线程

t1.start()

t2.start()

t1.join()

t2.join()

print("n:", n)

#输出

n: 20

可以看出，多线程之间是共享全局变量的

互斥锁

由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁，即同一时刻允许一个线程执行操作。

由于线程之间是进行随机调度，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期，我们也称此为“线程不安全”。

当把计算的数据很大，就会出现资源竞争，导致执行的结果不准确

image.png

为了方式上面情况的发生，就出现了互斥锁(Lock)，在可能出现资源竞争的地方加上互斥锁，保证线程的安全

import threading

n = 100

def work1():

global n

for i in range(500000):

lock.acquire()

n += 1

lock.release()

def work2():

global n

for i in range(500000):

lock.acquire()

n += 1

lock.release()

# 创建一把锁

lock = threading.Lock()

# 上锁

t1 = threading.Thread(target=work1)

t2 = threading.Thread(target=work2)

# 启动线程

t1.start()

t2.start()

t1.join()

t2.join()

print("n:", n)

三、GIL(Global Interpreter Lock)全局解释器锁

在非python环境中，单核情况下，同时只能有一个任务执行。多核时可以支持多个线程同时执行。但是在python中，无论有多少核，同时只能执行一个线程。究其原因，这就是由于GIL的存在导致的。

GIL的全称是Global Interpreter Lock(全局解释器锁)，来源是python设计之初的考虑，为了数据安全所做的决定。某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。GIL只在cpython中才有，因为cpython调用的是c语言的原生线程，所以他不能直接操作cpu，只能利用GIL保证同一时间只能有一个线程拿到数据。而在pypy和jpython中是没有GIL的。

Python多线程的工作过程：

python在使用多线程的时候，调用的是c语言的原生线程。

拿到公共数据

申请GIL

python解释器调用os原生线程

os操作cpu执行运算

当该线程执行时间到后，无论运算是否已经执行完，gil都被要求释放

进而由其他进程重复上面的过程

等其他进程执行完后，又会切换到之前的线程(从他记录的上下文继续执行)，整个过程是每个线程执行自己的运算，当执行时间到就进行切换(context switch)。

python中线程的缺陷，以及适用场景：

由于GIL锁的存在，python中的多线程在同一时间没办法同时执行(即没办法实现并行)

1、CPU密集型代码(各种循环处理、计算等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到阈值，然后触发GIL的释放与再竞争(多个线程来回切换当然是需要消耗资源的)，所以python下的多线程对CPU密集型代码并不友好。

2、IO密集型代码(文件处理、网络爬虫等涉及文件读写的操作)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好。

练习：

有10000个url地址(假设请求每个地址需要0.5秒)，请设计程序一个程序，获取列表中的url地址，使用1000个线程去发送这10000个请求，计算出总耗时！

# 计算时间的装饰器

def decorator(func):

def wrapper():

# 函数执行之前获取系统时间

start_time = time.time()

func()

# 函数执行之后获取系统时间

end_time = time.time()

print('执行时间为：', end_time - start_time)

return end_time - start_time

return wrapper

#生成器生成10000个url地址

urls_g = (f"https://www.baidu.com{j}" for j in range(10000))

#定义线程类

class MyThread(threading.Thread):

#重写run方法，指定要执行的任务逻辑

def run(self):

while True:

try:

url = next(urls_g)

except StopIteration:

break

else:

print(F'{self}发送请求{url}')

time.sleep(0.5)

@decorator

def main():

t_list = []

# 创建4个线程

for i in range(1000):

t = MyThread() # 创建线程对象

t.start() # 开启该线程

t_list.append(t)

# 遍历所有线程对象，设置主线等待子线程执行完

for t in t_list:

t.join()

res = main()

最终执行时间为5.16秒，如果单线程执行的话至少需要5000多秒，体现了多线程在执行IO密集型任务时的性能效率