多线程

多线程

1线程理论知识

  • 什么是线程
    • 线程就是一条流水线
    • 进程 : 划分空间,加载资源,静态的.
    • 线程 : 执行代码,执行能力,动态的
  • 线程VS进程
    • 开启多进程开销非常大,开启线程开销非常小
    • 开启多进程的速度慢,开启多线程速度快
    • 进程之间数据不能直接共享,通过队列可以,同一进程下的线程之间的数据可以共享
  • 多线程的应用场景介绍
    • 并发:一个cpu来回切换,多进程并发,多线程的并发
    • 多进程并发:开启多个进程,每个进程里面的主线程执行任务
    • 多线程并发:开启一个进程,进程里面的多个线程执行任务

2.开启线程的两种方式

  • 第一种方式

    • # 第一种方式
      # from threading import Thread
      #
      # def task(name):
      #     print(f'{name} is running')
      #
      # if __name__ == '__main__':
      #     t = Thread(target=task,args=('mcsaoQ',))
      #     t.start()
      #
      #     print('主线程')
      
  • 第二种方式

    • from threading import Thread
      
      
      class MyThread(Thread):
      
      
          def run(self):
              print(f'{self.name} is running')
      
      
      if __name__ == '__main__':
          t = MyThread()
          t.start()
      
          print('主线程')
      

3.线程与进程之间的对比

  • 速度的对比

    • from threading import Thread
      
      
      def task(name):
          print(f'{name} is running')
      
      
      
      if __name__ == '__main__':
          t = Thread(target=task,args=('mcsaoQ',))
          t.start()
      
          print('主线程')
      
      '''
      线程绝对要比进程要快:
          mcsaoQ is running
          主线程
      '''
      
  • pid

    • # pid 进程号
      from threading import Thread
      import os
      
      def task():
          print(f'子线程: {os.getpid()}')
      
      
      
      if __name__ == '__main__':
          t = Thread(target=task,)
          t.start()
      
          print(f'主线程: {os.getpid()}')
      
  • 线程之间的共享资源

    • # from threading import Thread
      #
      # x = 1000
      #
      # def task():
      #     global x
      #     x = 0
      #
      #
      # if __name__ == '__main__':
      #     t = Thread(target=task)
      #     t.start()
      #     # t.join()
      #     print(f'主线程: {x}')
      
      
      
      
      # from threading import Thread
      # import time
      # x = 1000
      #
      # def task():
      #     time.sleep(3)
      #     print('子线程....')
      #
      #
      # def main():
      #     print('111')
      #     print('222')
      #     print('333')
      #
      # #
      # # task()
      # # main()
      #
      # if __name__ == '__main__':
      #     t = Thread(target=task)
      #     t.start()
      #     # t.join()
      #     main()
      

4.线程的其他方法

  • # from threading import Thread
    # import threading
    # import time
    #
    #
    # def task(name):
    #     time.sleep(1)
    #     print(f'{name} is running')
    #     print(threading.current_thread().name)
    #
    #
    #
    # if __name__ == '__main__':
    #     for i in range(5):
    #         t = Thread(target=task,args=('mcsaoQ',))
    #         t.start()
    #     # 线程对象的方法:
    #     # time.sleep(1)
    #     # print(t.is_alive())  # 判断子线程是否存活  ***
    #     # print(t.getName())  # 获取线程名
    #     # t.setName('线程111')
    #     # print(t.getName())  # 获取线程名
    #
    #     # threading模块的方法:
    #     # print(threading.current_thread().name)  # MainThread
    #     # print(threading.enumerate())  # 返回一个列表 放置的是所有的线程对象
    #     print(threading.active_count())  # 获取活跃的线程的数量(包括主线程)
    #     print('主线程')
    

5.守护线程

  • 守护:子线程守护主线程,

  • 结束条件:守护线程必须等待主线程结束才结束,主线程必须等所有的非守护线程结束才能结束

  • from threading import Thread
    
    import time
    
    def foo():
        print(123)
        time.sleep(3)
        print("end123")
    def bar():
        print(456)
        time.sleep(1)
        print("end456")
    if __name__ == '__main__':
        t1=Thread(target=foo)
        t2=Thread(target=bar)
    
        t1.daemon = True
        t1.start()
        t2.start()
        print("main-------")
    

6.互斥锁(同步锁)

7.死锁现象,递归锁

  • 进程由死锁与递归锁,与线程同理,

  • 死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去,此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁

    • from threading import Thread
      from threading import Lock
      import time
      
      lock_A = Lock()
      lock_B = Lock()
      
      
      class MyThread(Thread):
      
          def run(self):
              self.f1()
              self.f2()
      
          def f1(self):
              lock_A.acquire()
              print(f'{self.name}拿到A锁')
      
              lock_B.acquire()
              print(f'{self.name}拿到B锁')
              lock_B.release()
      
              lock_A.release()
      
          def f2(self):
              lock_B.acquire()
              print(f'{self.name}拿到B锁')
              time.sleep(0.1)
      
              lock_A.acquire()
              print(f'{self.name}拿到A锁')
              lock_A.release()
      
              lock_B.release()
      
      if __name__ == '__main__':
          for i in range(3):
              t = MyThread()
              t.start()
      
          print('主....')
      
  • 解决死锁的方法:递归锁,在python中为了支持同一线程中多次请求同一资源,Python提供了可重入锁RLock

    • RLock内部维护着一个Lock和counter变量,counter记录了acquire的次数,从而使得资源可以被多次require,直到一个线程所有的acquire都被release,其他线程才能获取资源,上面的例子如果使用RLock代替Lock,则不会发生死锁:

    • from threading import Thread
      from threading import RLock
      import time
      
      lock_A = lock_B = RLock()
      
      
      class MyThread(Thread):
          
          def run(self):
              self.f1()
              self.f2()
          
          def f1(self):
              lock_A.acquire()
              print(f'{self.name}拿到A锁')
              
              lock_B.acquire()
              print(f'{self.name}拿到B锁')
              lock_B.release()
              
              lock_A.release()
          
          def f2(self):
              lock_B.acquire()
              print(f'{self.name}拿到B锁')
              time.sleep(0.1)
              
              lock_A.acquire()
              print(f'{self.name}拿到A锁')
              lock_A.release()
              
              lock_B.release()
      
      
      if __name__ == '__main__':
          for i in range(10):
              t = MyThread()
              t.start()
          
          print('主....')
      

8.信号量

  • Semaphore管理一个内置的计数器,每当调用acquire()时内置计数器+1,调用release()时内置计数器-1,计数器不能小于0,当计数器为0时,acquire()将阻塞线程直到其他线程调用release(),

  • from threading import Thread
    from threading import Semaphore
    from threading import current_thread
    import time
    import random
    
    sem = Semaphore(5)
    
    def go_public_wc():
        sem.acquire()
        print(f'{current_thread().getName()} 上厕所ing')
        time.sleep(random.randint(1,3))
        sem.release()
    
    
    if __name__ == '__main__':
        for i in range(20):
            t = Thread(target=go_public_wc)
            t.start()
    
posted @ 2019-07-24 16:11  恰蜜小嘴  阅读(90)  评论(0编辑  收藏  举报