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

并发编程之多线程

• 什么是线程？

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

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

• 进程和线程的区别

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

• 为什么要用多线程

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

• 开启进程的两种方式

  • 方式一

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

  • 方式二

    • from threading import Thread
      import time
      class myt(Thread):
          def run(self):
              print("线程开启
      ")
              time.sleep(2)
              print("线程结束
      ")
      if __name__ == '__main__':
          t= myt()
          t.start()
          print("主进程")
      

• 线程与进程运行速度比较

  • from threading import Thread
    from multiprocessing import Process
    def task():
        print("线程开启")
        print("线程结束
    ")
    
    def task1():
        print("进程开启")
        print("进程结束
    ")
    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("线程开启
    ")
        time.sleep(2)
        print("线程结束
    ")
    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("这是子线程开始
      ")
          time.sleep(2)
          print("这是子线程结束")
      if __name__ == '__main__':
          t = Thread(target=task)
          #将线程变成守护线程
          t.daemon = True
          t.start()
          print("这是主线程")