37.从入门到精通：Python3 多线程 线程模块 使用 threading 模块创建线程 线程同步 线程优先级队列（ Queue）_python3 threading

Python3 多线程

线程模块

在Python 3中，线程模块已被重命名为_thread，同时还引入了更高级别的 threading 模块，它允许创建线程对象并提供了更多的方法来控制线程的行为。
以下是一个简单的示例，演示如何使用 threading 模块创建并启动线程：

import threading

def print_numbers():
    for i in range(1, 11):
        print(i)

thread1 = threading.Thread(target=print_numbers)
thread1.start()

print("Main thread exiting...")
1
2
3
4
5
6
7
8
9
10

在这个例子中，我们创建了一个名为 print_numbers 的函数，它将打印数字 1 到 10。然后，我们创建一个名为 thread1 的线程对象，将 print_numbers 函数作为目标传递给它。最后，我们调用 start 方法来启动线程。

注意，在这个例子中，主线程会继续执行，并且会在子线程完成之前退出。如果您希望等待线程完成后再退出，可以使用 join 方法：

import threading

def print_numbers():
    for i in range(1, 11):
        print(i)

thread1 = threading.Thread(target=print_numbers)
thread1.start()

thread1.join()

print("Main thread exiting...")
1
2
3
4
5
6
7
8
9
10
11
12

在这个例子中，我们添加了一个 join 方法来等待线程完成。这样，主线程将等待子线程完成后再退出。

使用 threading 模块创建线程

使用 Python 的 threading 模块可以方便地创建和管理多个线程。以下是一个简单的示例：

import threading

def worker():
    """线程要执行的任务"""
    print('Worker')

threads = []
for i in range(5):
    t = threading.Thread(target=worker)
    threads.append(t)
    t.start()

# 等待所有线程完成
for t in threads:
    t.join()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这个示例创建了 5 个线程，每个线程都执行 worker 函数。使用 threading.Thread 创建线程对象，传递一个 target参数，该参数是要在线程中执行的函数。然后使用 start 方法启动线程。最后，使用 join 方法等待所有线程完成。

需要注意的是，在多线程编程中，需要注意线程之间的同步问题，例如共享资源的访问问题等。可以使用锁、信号量等同步机制来解决这些问题。

线程同步

线程同步是指多个线程在访问共享资源时，通过协作来避免竞争条件的发生。在多线程编程中，如果没有进行适当的同步，可能会导致数据不一致或者程序崩溃等问题。
Python 中提供了多种方式来实现线程同步，下面介绍两种常用的方式：

锁（Lock）：锁是最常用的同步机制，它可以防止多个线程同时访问共享资源。当一个线程获得锁时，其他线程必须等待该线程释放锁后才能访问共享资源。在 Python 中，可以使用 threading 模块中的 Lock 类来实现锁。

下面是一个简单的示例，演示如何使用 Lock 实现线程同步：

import threading

x = 0
lock = threading.Lock()

def increment():
    global x
    for i in range(100000):
        lock.acquire()
        x += 1
        lock.release()

def decrement():
    global x
    for i in range(100000):
        lock.acquire()
        x -= 1
        lock.release()

t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=decrement)

t1.start()
t2.start()

t1.join()
t2.join()

print("x = ", x)
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
27
28
29

在这个例子中，我们创建了两个线程，一个线程用于增加变量 x 的值，另一个线程用于减少变量 x 的值。为了避免竞争条件，我们使用 Lock对象来控制对变量 x 的访问。

条件变量（Condition）：条件变量是一种高级别的同步机制，它允许线程在满足特定条件时等待或者继续执行。在 Python 中，可以使用 threading 模块中的 Condition 类来实现条件变量。

下面是一个简单的示例，演示如何使用 Condition 实现线程同步：

import threading

x = 0
condition = threading.Condition()

def increment():
    global x
    for i in range(100000):
        with condition:
            while x >= 5:
                condition.wait()
            x += 1
            condition.notify()

def decrement():
    global x
    for i in range(100000):
        with condition:
            while x <= 0:
                condition.wait()
            x -= 1
            condition.notify()

t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=decrement)

t1.start()
t2.start()

t1.join()
t2.join()

print("x = ", x)
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
27
28
29
30
31
32
33

在这个例子中，我们创建了两个线程，一个线程用于增加变量 x 的值，另一个线程用于减少变量 x 的值。为了避免竞争条件，我们使用
Condition 对象来控制对变量 x 的访问。在增加或减少变量 x 的值时，我们使用 wait 方法来等待特定的条件，使用 notify
方法来通知其他线程条件已经满足。

线程优先级队列（ Queue）

线程优先级队列（Queue）是 Python 标准库中的一个模块，它提供了多线程编程中常用的队列数据结构，支持多线程间的安全数据交换和同步。
Queue 模块提供了三种类型的队列：FIFO（先进先出）队列、LIFO（后进先出）队列和优先级队列。其中，优先级队列是一种支持按照元素优先级排序的队列，优先级高的元素先被取出。
以下是一个使用优先级队列的简单示例：

import queue

q = queue.PriorityQueue()

q.put((2, 'code'))
q.put((1, 'eat'))
q.put((3, 'sleep'))

while not q.empty():
    item = q.get()
    print(item[0], item[1])

输出结果：
1 eat
2 code
3 sleep
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，我们创建了一个优先级队列，并使用 put
方法将三个元素插入队列中，每个元素都是一个元组，第一个元素表示优先级，第二个元素是具体的数据。然后我们使用 get
方法从队列中取出元素，队列会按照元素的优先级从高到低排序，优先级相同的元素按照插入顺序排序。

需要注意的是，queue 模块提供的队列都是线程安全的，可以在多线程环境中使用。在多线程编程中，可以使用队列来实现线程之间的数据交换和同步。