你真的了解线程的基础知识吗？这些技巧让你的代码更高效！-51CTO.COM

当涉及到多任务处理时，线程是一种非常实用的技术。Python语言提供了内置的线程支持库，使得创建和管理线程变得非常容易。本文将深入介绍Python中的线程概念，线程创建和管理，线程状态和生命周期，线程的属性和方法以及线程的调度和优先级。

线程概念和基本原理

线程是进程中的执行单元，每个线程都有自己的执行路径和执行状态。一个进程可以包含多个线程，每个线程都可以同时执行不同的任务。线程是轻量级的，开销小，执行效率高，因此在高并发和多任务处理场景中得到广泛应用。

在Python中，线程是通过threading模块实现的。创建线程可以使用Thread类或继承Thread类自定义线程。线程的创建和启动可以使用start()方法。

import threading

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)

# 创建线程
t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_numbers)

# 启动线程
t1.start()
t2.start()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

上面代码中，我们创建了两个线程t1和t2，用于执行print_numbers函数。通过start()方法启动线程后，两个线程会同时执行print_numbers函数。

线程的状态和生命周期

线程在运行过程中会出现不同的状态，包括新建状态、就绪状态、运行状态、阻塞状态和终止状态。线程的状态可以通过is_alive()方法查询。

线程的生命周期包括线程创建、线程就绪、线程运行、线程阻塞和线程终止。线程的生命周期可以通过join()方法控制。

import threading

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)

# 创建线程
t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_numbers)

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

print("All threads have finished")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

上面代码中，我们使用join()方法等待线程t1和t2执行完毕后才输出"All threads have finished"。这种等待方式可以保证主线程在所有子线程执行完毕后再退出。

线程的属性和方法

Python中的线程有很多属性和方法，可以让我们更加灵活地控制线程的执行。下面将详细讲解线程的属性和方法，以及每个方法的作用和代码示例。

线程属性

name属性

name属性用于获取或设置线程的名称。线程的名称可以是任意字符串。

import threading

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)

# 创建线程并设置名称
t1 = threading.Thread(target=print_numbers, name="Thread 1")
t2 = threading.Thread(target=print_numbers, name="Thread 2")

# 获取线程名称
print(t1.name)
print(t2.name)

# 启动线程
t1.start()
t2.start()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

daemon属性

daemon属性用于设置线程是否为守护线程。守护线程是一种特殊的线程，当所有非守护线程执行完毕后，守护线程自动退出。

import threading
import time

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)
        time.sleep(0.5)

# 创建线程并设置为守护线程
t1 = threading.Thread(target=print_numbers, name="Thread 1")
t2 = threading.Thread(target=print_numbers, name="Thread 2", daemon=True)

# 获取线程守护状态
print(t1.daemon)
print(t2.daemon)

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

print("All threads have finished")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

ident属性

ident属性用于获取线程的标识符。线程的标识符是一个整数，唯一标识该线程。

import threading

# 线程函数
def print_ident():
    print(threading.current_thread().name, ":", threading.current_thread().ident)

# 创建线程
t1 = threading.Thread(target=print_ident, name="Thread 1")
t2 = threading.Thread(target=print_ident, name="Thread 2")

# 启动线程
t1.start()
t2.start()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

is_alive()方法

is_alive()方法用于判断线程是否在运行。

import threading
import time

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)
        time.sleep(0.5)

# 创建线程
t1 = threading.Thread(target=print_numbers, name="Thread 1")
t2 = threading.Thread(target=print_numbers, name="Thread 2")

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

# 判断线程是否在运行
print(t1.is_alive())
print(t2.is_alive())1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

线程方法

start()方法

start()方法用于启动线程。一旦线程启动，它将执行target指定的函数。

import threading
import time

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)
        time.sleep(0.5)

# 创建线程
t1 = threading.Thread(target=print_numbers, name="Thread 1")
t2 = threading.Thread(target=print_numbers, name="Thread 2")

# 启动线程
t1.start()
t2.start()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

join()方法

join()方法用于等待线程执行完毕。如果不使用join()方法，主线程将在子线程之前结束，导致子线程被强制结束。

import threading
import time

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)
        time.sleep(0.5)

# 创建线程
t1 = threading.Thread(target=print_numbers, name="Thread 1")
t2 = threading.Thread(target=print_numbers, name="Thread 2")

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

print("All threads have finished")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

run()方法

run()方法是线程执行时调用的方法。默认情况下，run()方法调用target指定的函数。

import threading
import time

# 线程类
class MyThread(threading.Thread):
    def run(self):
        for i in range(10):
            print(self.name, ":", i)
            time.sleep(0.5)

# 创建线程
t1 = MyThread(name="Thread 1")
t2 = MyThread(name="Thread 2")

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

print("All threads have finished")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

sleep()方法

sleep()方法用于将线程休眠一段时间。在休眠期间，线程不会执行任何操作。

import threading
import time

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)
        time.sleep(0.5)

# 创建线程
t1 = threading.Thread(target=print_numbers, name="Thread 1")
t2 = threading.Thread(target=print_numbers, name="Thread 2")

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

# 休眠线程
time.sleep(1)

print("All threads have finished")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

enumerate()方法

enumerate()方法用于返回当前正在运行的所有线程。

import threading

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)

# 创建线程
t1 = threading.Thread(target=print_numbers, name="Thread 1")
t2 = threading.Thread(target=print_numbers, name="Thread 2")

# 启动线程
t1.start()
t2.start()

# 获取所有正在运行的线程
for thread in threading.enumerate():
    print(thread.name)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

active_count()方法

active_count()方法用于返回当前正在运行的线程数。

import threading

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)

# 创建线程
t1 = threading.Thread(target=print_numbers, name="Thread 1")
t2 = threading.Thread(target=print_numbers, name="Thread 2")

# 启动线程
t1.start()
t2.start()

# 获取正在运行的线程数
print(threading.active_count())1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

线程的调度和优先级

线程调度是指多个线程之间的竞争和协作机制，通过优先级和时间片轮转等方式来调度线程的执行。Python中可以通过threading模块的setpriority()方法设置线程的优先级。线程的优先级可以是整数，范围为0到sys.maxsize。

在Python中，线程的优先级仅仅是一个建议，具体的线程调度由操作系统来完成。

import threading

# 线程函数
def print_numbers():
    for i in range(10):
        print(threading.current_thread().name, ":", i)

# 创建线程
t1 = threading.Thread(target=print_numbers, name="Thread 1")
t2 = threading.Thread(target=print_numbers, name="Thread 2")

# 设置线程优先级
t1.setpriority(1)
t2.setpriority(2)

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

print("All threads have finished")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

上面代码中，我们使用setpriority()方法设置线程的优先级，t1的优先级为1，t2的优先级为2。线程的优先级越高，在竞争CPU资源时就越有可能被调度执行。

总结

本文介绍了Python中线程的基础知识，包括线程概念和基本原理，线程的创建和管理，线程状态和生命周期，线程的属性和方法以及线程的调度和优先级。如果您需要在Python中进行多任务处理，线程将是一个非常实用的技术，可以提高程序的效率和性能。