使用 threading 这个模块(就是一个文件)

重要的 class

Thead(和Java的基本一致)

  1. start
  2. run 使用Thread类的target属性时，实际上相当于将目标函数指定为线程的run方法
  3. join(timeout=None)
    • 作用: 用来进行线程同步
    • 参数
      • timeout: 如果在 timeout这个时间内都没有执行join成功，就往下执行，不再等待同步
  4. is_alive
    • 作用：判定线程是否活着

使用

  1. start&join
    import threading


def p_thread_runner(*args):
    i = 0
    while args[0][0] is True:
        print(i)
        i += 1


if __name__ == '__main__':
    can_run = [True]
    p_thead = threading.Thread(target=p_thread_runner, args=(can_run,))
    p_thead.start()
    # can_run[0] = False
    # 用来同步的
    p_thead.join(timeout=0)
  2. run的重写
    import threading
import time


class MyThread(threading.Thread):

    def run(self) -> None:
        super().run()
        for i in range(5):
            print(f"Thread {self.name} is running - {i}")
            # 和 asyncio 里面的一样吗
            time.sleep(1)


# 创建两个线程实例
thread1 = MyThread()
thread2 = MyThread()

# 启动线程，实际上是调用了 run 方法
thread1.start()
thread2.start()

# 等待线程执行完成
thread1.join()
thread2.join()

print("Main thread continues...")

Lock

使用

  1. with&acquire_release
    import threading

my_lock = threading.Lock()

with my_lock:
    print('类似 with open 的文件操作一样，这里的操作是原子性的')

my_lock.acquire()
print('通过 acquire 和 release 中间的操作也是原子性的')
my_lock.release()

Event

作用

  • 类似一个sleep，你叫他sleep就sleep

使用

  1. set/clear/wait
    
import threading
import time


def worker(event, thread_id):
    print(f"Thread {thread_id} is waiting for the event.")
    event.wait()  # 等待事件触发
    print(f"Thread {thread_id} received the event and continues.")


# 创建 Event 实例
my_event = threading.Event()

# 创建线程
thread1 = threading.Thread(target=worker, args=(my_event, 1))
thread2 = threading.Thread(target=worker, args=(my_event, 2))

# 启动线程
thread1.start()
thread2.start()

# 主线程等待一段时间
time.sleep(2)

# 主线程触发事件
print("Main thread sets the event.")
my_event.set()

# 等待线程执行完成
thread1.join()
thread2.join()

print("Main thread continues.")

Condition

作用

  • 用于实现线程间的协调和同步。Condition 类提供了一种更高级别的锁定机制

Semaphore(信号量)

作用

  • 信号量是一种更为灵活的同步原语，它允许多个线程同时访问共享资源，但限制同时访问的线程数量。