一、多线程相关概念

1.并发和并行的区别

并发和并行是即相似又有区别的两个概念，并行是指两个或者多个事件在同一时刻同时执行，而并发是指两个或多个事件通过时间片轮流被执行。从计算机工作原理的角度出发，“并发”只是相对较短的一时间段中的同时性。集合点是为了确保“严格意义上”的并发，尽量让这些并发的虚拟用户在同一时刻执行任务，但严格意义上的“并发”可以说是不存在 的！

2.线程和进程的区别

进程：进程在操作系统中可以独立运行，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间。

线程：线程是进程中的一个实例，作为系统（CPU）调度和分派的基本单位，它与同属一个进程的其他的线程共享进程所拥有的全部资源。

二、创建多线程：threading

在Python 3标准库中，有两个模块_thread和threading可以提供多线程支持。但由于_thread是低级模块，很多功能还不完善，一般只会用到threading这个比较完善的高级模块，因此这里只讨论threading模块的使用。 Python中使用线程有两种方式：函数或者用类来包装线程对象。

1.函数创建多线程

采用函数创建多线程语法如下:

threading.Thread ( function, args[, kwargs] )，参数说明：

• function - 线程函数。
• args - 传递给线程函数的参数，必须是个tuple类型。
• kwargs - 可选参数。

import threading

def info(name, city):
    print(f"my name is {name}, I com from {city}")

t = threading.Thread(target=info, args=("周润发", "香港"))
t.start()  # my name is 周润发, I com from 香港

2.继承Thread类来创建多线程

我们也可以通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法。继承Thread类来创建多线程的方式需要重写Thread中的run()方法，run方法中是该线程要执行的动作。

class NewThreading(threading.Thread):
    def __init__(self, thread_name):
        super(NewThreading, self).__init__()
        self.thread_name = thread_name

    def run(self):
        print(f"线程{self.thread_name}启动...")
        print(f"线程{self.thread_name}退出...")


nt = NewThreading("new threading")
nt.start()

'''
线程new threading启动...
线程new threading退出...
'''

三、获取正在运行的线程数量

threading 模块提供了两种方法可以获取线程的数量，一个是threading.enumerate()，一个是threading.activeCount()

• threading.enumerate()返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
• threading.activeCount()返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

def a():
    time.sleep(1)
    print("this is function a")


def b():
    # 加延时，enumerate才能统计到，否则时间太快、主线程和子线程都跑完了，enumerate统计不到
    time.sleep(1)
    print("this is function b")


if __name__ == '__main__':
    "使用Thread方法创建子线程对象的时候，并不会创建线程,当子线程对象调用start()方法的时候，才开始创建子线程，并且线程开始运行"
    t1 = threading.Thread(target=a)
    t1.start()
    t2 = threading.Thread(target=b)
    t2.start()
    # 获取正在运行的线程数量，enumerate只统计正在运行的线程
    print(type(threading.enumerate()))  # <class 'list'>
    print(threading.enumerate())
    print(threading.activeCount())  # 3
    print(threading.active_count())  # 3
    
'''
[<_MainThread(MainThread, started 1780)>, <Thread(Thread-1, started 19124)>, <Thread(Thread-2, started 19476)>]
2
'''

注意：

1. 在使用threading.enumerate()方法统计线程数量的时候，需要加个延时才能统计到，否则时间太快、主线程和子线程都跑完了，enumerate统计不到；
2. threading.enumerate()只统计正在运行的线程，启动前和终止后的线程不统计；
3. threading.enumerate()的返回值是一个包含了主线程和所有子线程的列表；
4. 使用Thread方法创建子线程对象的时候，并不会创建线程，当子线程对象调用start()方法的时候，才开始创建子线程，并且线程开始运行；
5. threading.activeCount()方法和threading.active_count()作用一直，都是获取线程数量，相当于执行了len(threading.enumerate())，也就是获取线程列表的长度；

四、多线程常用方法

1.获取线程名称

“线程名.name”和“线程名.getName()”方法都能获取线程名

def info(name, city):
    print(f"my name is {name}, I come from {city}")


if __name__ == '__main__':
    t = threading.Thread(target=info, args=("周润发", "香港"))
    t.start()  # my name is 周润发, I come from 香港
    print(t.name)  # Thread-1
    print(t.getName())  # Thread-1

2.设置线程名称

通过“线程名.getName”设置线程名后，再通过“线程名.getName()”方法获取到的就是新设置的线程名。

t.setName("new thread")
print(t.getName())  # new thread

3.获取线程id

通过“线程名.ident”获取线程id

print(t.ident)

4.判断线程是否为激活状态

通过“线程名.is_alive()”方法判断线程是否处于激活状态，返回值为布尔值，True表示在运行，False表示不在运行

print(t.isAlive())  # False
print(t.is_alive())  # False

isAlive方法已弃用，可以用is_alive代替

5.多线程中的join方法

join()方法：主线程A中，创建了子线程B，并且在主线程A中调用了B.join()，那么，主线程A会在调用的地方等待，直到子线程B完成操作后，才可以接着往下执行，join方法一般用在子线程和主线程有强关联的场景中，如果主线程和子线程没有强关联的情况，不建议使用join。

语法：join([timeout])

参数为可选，代表线程运行的最大时间，即如果超过这个时间，不管这个子线程有没有执行完毕都会被回收，然后主线程或函数都会接着执行。

未使用join方法时

未使用join方法时，程序会先执行主线程中的语句，即先打印"hello world 2"，再打印"hello world 3"，主线程执行完成后，再执行子线程中的逻辑，即执行hello函数、打印"hello world 1"

def hello():
    time.sleep(1)
    print("hello world 1")


if __name__ == '__main__':
    t = threading.Thread(target=hello)
    t.start()
    print("hello world 2")
    print("hello world 3")

'''
hello world 2
hello world 3
hello world 1
'''

使用join方法后

使用join方法后，程序会先执行子线程中的逻辑，即执行hello函数、打印"hello world 1"，等待子线程执行完成后，再执行主线程中的语句，即先打印"hello world 2"，再打印"hello world 3"，相当于main函数中实现了顺序执行。

def hello():
    time.sleep(1)
    print("hello world 1")


if __name__ == '__main__':
    t = threading.Thread(target=hello)
    t.start()
    print("hello world 2")
    print("hello world 3")

'''
hello world 1
hello world 2
hello world 3
'''

另外join函数还带有timeout的参数，即超时时间，单位为秒，当传入timeout参数后，例如1秒，程序会先执行子线程的内容，1秒后，不管子线程有没有执行完，都会执行主线程的内容：

t.join(timeout=1)

6.设置守护线程

子线程可以通过“线程名.setDaemon(True)”方法设置守护线程，True表示生效，False表示不生效，设置守护线程的作用是，当主线程执行完成后，子线程会自动随主线程结束而结束，而不会等待子线程执行完再关闭，也就是忽略了子线程。

注意：守护线程不能在线程处于的激活状态下设置，否则会报下列运行时错误：

正确的写法是setDaemon(True)要写在线程启动语句的前面：

import time
import threading


def info():
    time.sleep(2)
    print("my name is 周润发")


if __name__ == '__main__':
    t = threading.Thread(target=info)
    t.setDaemon(True)
    t.start()
    print("I come from HONG KONG")

当setDaemon参数为True时表示守护线程设置生效，可以看到下面只执行了主线程的内容，当主线程结束后，子线程会随着主线程的结束而结束，并没有执行子线程、也就是执行info函数。

当setDaemon参数为False时表示守护线程设置未生效，先执行了主线程打印了"I come from HONG KONG"，后又执行了子线程、也就是执行了info函数，打印了"my name is 周润发"。

小结

1. 创建多线程有两种方式：一种是通过函数创建，一种是通过继承threading.Thread类创建；
2. 获取线程数量也有两种方式：threading.enumerate()、threading.activeCount()；
3. 多线程常用方法：

• 获取线程名称：线程名.name、线程名.getName()
• 设置线程名称：线程名.setName()
• 获取线程ID：线程名.ident
• 判断线程是否处于激活状态：线程名.is_alive()

4. join方法的作用：等待子线程执行结束后、或等待指定时长后再执行主线程的内容；
5. 设置守护线程：线程名.setDaemon(True)，作用是当主线程结束后，子线程会随着主线程的结束而结束，不会执行子线程；