张芷铭的个人博客

控制进程顺序

在某些情况下，你可能需要控制线程之间的执行顺序。可以通过以下几种方法实现：

1. 使用锁（Lock）

锁可以确保只有一个线程在同一时间执行特定的代码块，从而可以控制线程的执行顺序。

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import threading

lock = threading.Lock()

def worker(name, order):
    with lock:
        print(f"Thread {name} starting")
        # 可以添加更多逻辑来控制执行顺序
        order.append(name)
        print(f"Thread {name} finished")

threads = []
order = []

for i in range(5):
    t = threading.Thread(target=worker, args=(i, order))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"Execution order: {order}")

2. 使用条件变量（Condition）

条件变量可以让线程等待特定的条件满足后再继续执行。

示例

 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

import threading

condition = threading.Condition()
current_order = 0

def worker(name, order):
    global current_order
    with condition:
        while name != current_order:
            condition.wait()
        print(f"Thread {name} starting")
        order.append(name)
        print(f"Thread {name} finished")
        current_order += 1
        condition.notify_all()

threads = []
order = []

for i in range(5):
    t = threading.Thread(target=worker, args=(i, order))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"Execution order: {order}")

3. 使用事件（Event）

事件是线程间的一种简单的同步机制，适用于控制线程的启动和暂停。

示例

 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

import threading

start_event = threading.Event()

def worker(name, order, start_event):
    start_event.wait()
    print(f"Thread {name} starting")
    order.append(name)
    print(f"Thread {name} finished")

threads = []
order = []

for i in range(5):
    t = threading.Thread(target=worker, args=(i, order, start_event))
    threads.append(t)
    t.start()

# 控制线程启动顺序
for i in range(5):
    print(f"Starting thread {i}")
    start_event.set()
    start_event.clear()
    threads[i].join()

print(f"Execution order: {order}")

4. 使用队列（Queue）

队列可以按照顺序处理任务，确保任务按顺序执行。

示例

 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
34
35
36
37
38

import threading
import queue

task_queue = queue.Queue()

def worker(order):
    while True:
        name = task_queue.get()
        if name is None:
            break
        print(f"Thread {name} starting")
        order.append(name)
        print(f"Thread {name} finished")
        task_queue.task_done()

threads = []
order = []

for i in range(5):
    t = threading.Thread(target=worker, args=(order,))
    threads.append(t)
    t.start()

# 将任务按顺序放入队列
for i in range(5):
    task_queue.put(i)

# 等待所有任务完成
task_queue.join()

# 停止所有线程
for i in range(5):
    task_queue.put(None)

for t in threads:
    t.join()

print(f"Execution order: {order}")

总结

通过使用锁、条件变量、事件和队列，可以在多线程环境中控制线程的执行顺序。每种方法都有其适用场景，可以根据具体需求选择合适的方式。了解这些同步机制的原理和用法，可以帮助你更灵活地控制线程的执行顺序和同步问题。

💬 评论