一、基本概念

什么是线程

线程（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密集型任务时的性能效率