Python入门笔记（十一）—— 多线程（上）

唰~~ 今天来讲多线程

线程概念

由于进程是资源拥有者，创建、撤消与切换存在较大的内存开销，因此需要引入轻型进程
即线程。
进程是资源分配的小单位,线程是CPU调度的小单位（程序真正执行的时候调用的是线
程）.每一个进程中至少有一个线程。

使用线程

import threading

def sing():
    for i in range(3):
        print("---正在唱歌---")
        time.sleep(1)

def dance():
    for i in range(3):
        print("---正在跳舞---")
        time.sleep(1)

def main():
    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)
    t1.start()
    t2.start()

if __name__ == '__main__':
    main()

###
---正在唱歌---
---正在跳舞---
---正在跳舞---
---正在唱歌---
---正在跳舞---
---正在唱歌---
###

首先程序运行时，程序从上往下走，遇到main()函数然后开始执行，执行mian()函数的函数
体时又创建了两个线程我们称之为子线程，程序运行时的线程我们称之为主线程
然后子线程根据target=xxx 开始执行指定的函数

• 传递参数

  使用线程的关键字 args=()进行传递参数
  

• join()方法

  当前线程执行完后其他线程才会继续执行

  import threading
  
  def sing(num):
      for i in range(3):
          print("---正在唱歌---")
          time.sleep(1)
  
  def dance(num):
      for i in range(3):
          print("---正在跳舞---")
          time.sleep(1)
  
  def main():
      t1 = threading.Thread(target=sing, args=(3,))
      t2 = threading.Thread(target=dance, args=(3,))
      t1.start()
      t1.join()
      t2.start()
  
  if __name__ == '__main__':
      main()
  
  ###
  ---正在唱歌---
  ---正在唱歌---
  ---正在唱歌---
  ---正在跳舞---
  ---正在跳舞---
  ---正在跳舞---
  ###
  

• setDeamon() 方法

  设为守护线程。
  在设为守护线程后，主线程结束守护线程也结束，不管是否执行。

  ##### 未设为守护线程
  
  def sayHi(name):
      time.sleep(2)
      print("%s say hello" %name)
  
  if __name__ == '__main__':
      t = threading.Thread(target=sayHi, args=("Nick",))
      t.start()
      print("主线程")
  
  ###
  主线程
  Nick say hello
  ###
  
  ##### 设为守护线程
  
  def sayHi(name):
      time.sleep(2)
      print("%s say hello" %name)
  
  if __name__ == '__main__':
      t = threading.Thread(target=sayHi, args=("Nick",))
      t.setDaemon(True)
      t.start()
      print("主线程")
  
  ###
  主线程
  ###
  

• 实例方法

  • getName() 获取线程的名称
  • setName() 设置线程的名称
  • isAlive() 判断当前线程存活状态

• threading模块提供的方法

  • threading.currentThread() 返回当前的线程变量
  • threading.enumerate() 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  • threading.activeCount() 返回正在运行的线程数量，与len(threading.enumerate())结果相同

• 使用继承方式开启线程

  import threading
  
  class MyThread(threading.Thread):
      def __init__(self, num):
          super().__init__()
          self.num = num
  
      def run(self):
          for i in range(self.num):
              print("...run...", i)
  
  if __name__ == '__main__':
      myThread = MyThread(3)
      myThread.start()
  

• 线程之间共享变量

  a = 100
  
  def test1():
      global a
      a += 1
      print(a)
  
  if __name__ == '__main__':
      t1 = threading.Thread(target=test1)
      t1.start()  # 101
  

  多线程开发的时候共享全局变量会带来资源竞争问题，数据不安全。
  可以通过锁，异步，各种设计模式来改进。

• 异步同步

  同步: 可以理解为线程A和B一块配合工作，A执行到一定程度时要依靠B的某个结果，于是停下来示意B执行，B执行完将结果给A,然后A继续执行。
  A强依赖B(对方)，A必须等到B的回复，才能做出下一步响应。即A的操作(行程)是顺序执行的，中间少了哪一步都不可以，或者说中间哪一步出错都不可以。

  异步: A并不强依赖B，A对B响应的时间也不敏感，无论B返回还是不返回，A都能继续运行；B响应并返回了，A就继续做之前的事情，B没有响应，A就做其他的事情。也就是说A不存在等待对方的概念。

---

鸽了好久的第一篇，希望大家2020年继续牛逼😉