并发编程之多线程(更新中...)

并发编程之多线程

  • 什么是线程?

    • 被cpu直接运行,一条线程指的是一个单一顺序中的控制流,一个进程中可以并行多个进程,每个并行执行不同的任务

    • 如果把操作系统比作一个车间的话,而进程就是一个个车间,线程就是车间里边的一条条流水线,电源就是cpu
  • 进程和线程的区别

    • - 线程 :单指代码的执行过程
      - 进程:资源的申请与销毁的过程
      - 进程内存空间彼此隔离
      - 同一进程下的线程可以共享资源
      - 进程需要申请资源开辟内存空间   慢
      - 线程只是告诉操作系统一个执行方案  快
  • 为什么要用多线程

    • - 多线程共享一个内存空间,节约资源
      - 线程比进程更容易创建,在许多操作系统中,创建一个线程比创建一个进程要快10-100倍,在有大量线程需要动态和快速修改时,这一特性很有用
      - 若多个线程都是cpu密集型的,那么并不能获得性能上的增强,但是如果存在大量的计算和大量的I/O处理,拥有多个线程允许这些活动彼此重叠运行,从而会加快程序执行的速度。
      - 若多个线程都是cpu密集型的,那么并不能获得性能上的增强,但是如果存在大量的计算和大量的I/O处理,拥有多个线程允许这些活动彼此重叠运行,从而会加快程序执行的速度。
  • 开启进程的两种方式

    • 方式一

      • from threading import Thread
        import time
        def task():
            print("线程开启\n")
            time.sleep(2)
            print("线程结束\n")
        if __name__ == '__main__':
            t = Thread(target=task)
            t.start()
            print("主线程")
        
    • 方式二

      • from threading import Thread
        import time
        class myt(Thread):
            def run(self):
                print("线程开启\n")
                time.sleep(2)
                print("线程结束\n")
        if __name__ == '__main__':
            t= myt()
            t.start()
            print("主进程")
  • 线程与进程运行速度比较

    • from threading import Thread
      from multiprocessing import Process
      def task():
          print("线程开启")
          print("线程结束\n")
      
      def task1():
          print("进程开启")
          print("进程结束\n")
      if __name__ == '__main__':
          t = Thread(target=task)
          t.start()
          print("主线程")
          p = Process(target=task1)
          p.start()
          print("主线程")
  • 线程共享内存空间

    • from threading import Thread
      x = 100
      def task():
          global x
          x =50
      t = Thread(target=task)
      t.start()
      print(x)
      def task1():
          global x
          x = 2
      t1 = Thread(target=task1)
      t1.start()
      print(x)
  • 线程中join用法

    • from threading import Thread
      import time
      def tast(name,time_):
          print(f"{name} 开启")
          time.sleep(time_)
          print(f"{name} 结束")
      if __name__ == '__main__':
          t1 = Thread(target=tast,args=('线程1',1))
          t2 = Thread(target=tast,args=('线程2',2))
          t3 = Thread(target=tast,args=('线程3',3))
          start = time.time()
          t1.start()
          t2.start()
          t3.start()
          t1.join()
          t2.join()
          t3.join()
          end = time.time()
          print("主线程")
          print(end-start)
  • 线程相关的其他方法

    •     print("线程开启\n")
          time.sleep(2)
          print("线程结束\n")
      if __name__ == '__main__':
          t = Thread(target=task)
          t.start()
          # 检测线程是否活动
          print(t.is_alive())
          #返回线程名字
          print(t.getName())
          #修改线程名字
          t.setName("线程1")
          print(t.getName())
          #返回当前线程变量
          print(threading.currentThread())
          #返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。
          print(threading.enumerate())
          # 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果
          print(threading.activeCount())
          print("主线程")
      
  • 守护进程

    • 等待主线程最后一行代码结束完毕之后销毁

      • from threading import Thread
        import time
        def task():
            print("这是子线程开始\n")
            time.sleep(2)
            print("这是子线程结束")
        if __name__ == '__main__':
            t = Thread(target=task)
            #将线程变成守护线程
            t.daemon = True
            t.start()
            print("这是主线程")
    原文作者:kuck
    原文地址: https://www.cnblogs.com/kuck/p/11536143.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞