Python高级学习第四课（寒假） 2022-1-8

• 信号量
  • 控制线程并发数
  • 一下子运行多线程可能卡顿，限定每次运行的线程数量，其他线程暂停，待当前限定的线程运行完成后再按照限定的数批量继续运行
  • 步骤
    • 在主线程定义一个实例化信号量

      '''括号中为设定的并发数，如为空则默认为1'''
      semaphore = threading.Semaphore()

    • 在运行函数中，先询问是否获取信号量再进行操作

      if semaphore.acquire():

    • 最后释放信号量

      semaphore.release()

  • 运用

    import threading
    import time
    
    class Mythread(threading.Thread):
        def __init__(self, num):
            super(Mythread, self).__init__()
            self.num = num
    
        def run(self):
            if semaphore.acquire():   # 获取信号量，将其锁住
    
                print("线程" + self.num)
                time.sleep(1)
                semaphore.release()   # 释放信号量
    
    if __name__ == '__main__':    # 主线程
        semaphore = threading.Semaphore(3)  # 定义一个信号量
        all_thread = []
        for i in range(100):
            all_thread.append(Mythread(str(i)))
        for j in all_thread:
            j.start()

• 条件变量
  • 是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待条件变量的条件成立而挂起;另一个线程使条件成立（给出条件成立信号）。
  • 步骤
    • 实例化定义

      con = threading.Condition()

    • 线程锁

      con.acquire()

    • 通知唤醒其他线程启动

      con.notify()

    • 等待线程挂起

      con.wait()

    • 释放锁

      con.release()

  • 可让前一个线程运行至一半开始运行下一个线程，以此类推运行

    import threading
    import time
    
    def run(x):
        con.acquire()                 # acquire模块运行，线程锁
        print(f'线程{x}')
        con.notify()                  # 通知其他线程，让挂起等待的启动
        print(f'线程{x}挂起')
        con.wait()                    # 等待，线程挂起
        time.sleep(1)
        print(f'线程{x}再次启动')
        con.notify()                  # 运行完后再唤醒其他的线程
        con.release()                 # 释放锁
    
    if __name__ == '__main__':
        con = threading.Condition()   # 实例化定义一个条件变量
        for i in range(10):
            t = threading.Thread(target=run, args=(i, ))
            t.start()

• 事件
  • 把其中一个线程中的一个变量作为一个信号传递给另一个线程中作为其函数启动的判断条件结果
  • 步骤
    • 实例化定义一个事件变量

      event = threading.Event()

    • 定义一个事件类，设置启动事件

      event.set()

    • 将启动的事件清除归位取消，回归到原始状态

      event.clear()

    • 在另一个类中判断事件是否被设置

      if event.is_set():

    • 如未被设置使等待

      event.wait()

  • 运用

    import threading
    import time
    
    class car(threading.Thread):
        def __init__(self, name):
            super(car, self).__init__()
            self.name = name
    
        def run(self):
            while 1:
                if event.is_set():  # 如果事件被设置
                    print(self.name + "启动")
                else:
                    print(self.name + "停止")
                    event.wait()    # 没有事件则等待
    
    class set_event(threading.Thread):
        def __init__(self):
            super(set_event, self).__init__()
        def run(self):
            while 1:
                event.set()         # 设置启动事件
                time.sleep(1)
                event.clear()       # 将启动的清除归位取消，回归到原始状态
                time.sleep(1)
    
    if __name__ == '__main__':
        event = threading.Event()   # 定义一个事件变量
        car_ = car("..")
        set_event_ = set_event()
    
        car_.start()
        set_event_.start()