使用 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(信号量)

作用

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