Python进阶-多任务编程-01

Python进阶系列
Python进阶-网络编程-01
Python进阶-网络编程-02
Python进阶-网络编程-03
Python进阶-多任务编程-01
Python进阶-多任务编程-02
Python进阶-多任务编程-03
Python进阶-正则表达式
Python进阶-数据库编程-01
Python进阶-数据库编程-02
Python进阶-数据库编程-03
Python进阶-数据库编程-04
Python进阶-数据拷贝问题
Python进阶-模块导入问题
Python进阶-miniWeb框架

6.1. 多任务的介绍

• 多任务：同一时间有多个任务在执行

• python程序默认是单任务

• 多任务的引入

  import time
  
  # 唱歌
  def sing():
      for i in range(5):
          print("正在唱歌")
          time.sleep(0.5)
  
  # 跳舞
  def dance():
      for i in range(5):
          print("正在跳舞")
          time.sleep(0.5)
  
  sing()
  dance()
  

---

6.2. 线程-基本使用

• 主线程：程序启动后有一个默认的主线，通常称为主线程

  作用：（1）创建子线程 （2）等子线程执行结束后，做关闭处理

• 子线程：程序的一个分支

• 子线程创建步骤：

  1. 导入模块 threading
  2. 使用 threading.Thread() 创建对象
  3. 指定子线程执行的分支
  4. 启动子线程

• 代码示例1：

  # 1.导入模块
  import threading
  import time
  
  
  def saySorry():
      print("对不起,我错了")
      time.sleep(0.5)
  
  
  if __name__ == '__main__':
      for i in range(5):
          # 2.使用 threading.Thread() 创建对象
          # 3.指定子线程执行的分支
          thread_obj = threading.Thread(target=saySorry)
          # 4.启动子线程
          thread_obj.start()
  

• 代码示例2：

  import time
  import threading
  
  # 唱歌
  def sing():
      for i in range(5):
          print("正在唱歌")
          time.sleep(0.5)
  
  # 跳舞
  def dance():
      for i in range(5):
          print("正在跳舞")
          time.sleep(0.5)
  
  if __name__ == '__main__':
      thread_sing = threading.Thread(target=sing)
      thread_dance = threading.Thread(target=dance)
  
      thread_sing.start()
      thread_dance.start()
  

---

6.3. 线程-线程名称、总数量

• 获取正在活跃的线程列表

  # 获取当前活跃的线程列表
  threading.enumerate()
  # 返回的结果为线程列表
  # [<_MainThread(MainThread, started 15236)>, 
  #  <Thread(Thread-1, started 2544)>, 
  #  <Thread(Thread-2, started 10472)>]
  

• 获取正在活跃的线程数量列表

  # 获取当前活跃的线程数量
  len(threading.enumerate())
  

• 获取正在活跃的线程名称

  # 获取当前线程的名称,其实就是线程列表里面的单个对象
  threading.current_thread() 
  

• 代码示例：

  import time
  import threading
  
  # 唱歌
  def sing():
      for i in range(5):
          print("正在唱歌",threading.current_thread())
          time.sleep(0.5)
  
  # 跳舞
  def dance():
      for i in range(5):
          print("正在跳舞",threading.current_thread())
          time.sleep(0.5)
  
  if __name__ == '__main__':
      # 线程的名称 : 当前的线程对象
      print(threading.current_thread())
  
      # 获取正在活跃的线程列表
      thread_list = threading.enumerate()
      print("1当前线程数量",len(thread_list))
  
      thread_sing = threading.Thread(target=sing)
      thread_dance = threading.Thread(target=dance)
  
      thread_sing.start()
      thread_dance.start()
  
      while True:
          thread_num = len(threading.enumerate())
          print("当前线程数量", thread_num)
  
          if thread_num <= 1:
              break
  
          time.sleep(0.5)
  

---

6.4. 线程-线程参数及顺序

• 线程参数

  1. 元组

     # 使用元组传参 threading.Thread(target=xxx,args=(参数1，参数2))
     thread_sing = threading.Thread(target=sing,args=(50,100,150))
     

  2. 字典

     # 使用字典传参 threading.Thread(target=xxx,kwargs={"参数名":参数值})
     thread_sing = threading.Thread(target=sing, kwargs={"a":50,"b":100,"c":150})
     

  3. 混合方式

     # 混合使用元组和字典
     thread_sing = threading.Thread(target=sing, args=(10,),kwargs={"b":100,"c":150})
     

• 代码示例：

  import time
  import threading
  
  # 唱歌
  def sing(a,b,c):
      print("参数:",a,b,c)
      for i in range(5):
          print("正在唱歌")
          time.sleep(0.5)
  
  # 跳舞
  def dance():
      for i in range(5):
          print("正在跳舞")
          time.sleep(0.5)
  
  if __name__ == '__main__':
      # 在线程中传递参数有三种方式:
      # 1.使用元组传参 threading.Thread(target=xxx,args=(参数1，参数2))
      # 2.使用字典传参 threading.Thread(target=xxx,kwargs={"参数名"：参数值})
      # 3.混合使用元组和字典
  
      # thread_sing = threading.Thread(target=sing,args=(50,100,150))
      # thread_sing = threading.Thread(target=sing, args=(10,),kwargs=            		    {"b":100,"c":150})
      thread_dance = threading.Thread(target=dance)
      thread_sing = threading.Thread(target=sing, kwargs={"a": 50, "b": 100, "c":      	   150})
  
      thread_sing.start()
      thread_dance.start()
  

• 线程顺序：线程的执行顺序是无序的(线程有CPU调度执行,CPU会根据系统的运行状态按照自己的调度算法去调度执行)

---

6.5. 线程-守护线程

• 线程守护：子线程和主线程的一种约定（当主线程结束后，子线程随之结束）

  # 子线程.setDaemon(True)
  

• 代码示例：

  import time
  import threading
  
  
  def work1():
      for i in range(10):
          print("正在执行work1",i)
          time.sleep(0.5)
  
  if __name__ == "__main__":
      thread_work = threading.Thread(target=work1)
  
      # 线程守护
      thread_work.setDaemon(True)
  
      thread_work.start()
  
      time.sleep(2)
      print("game over")
  

---

6.6. 并发与并行

• 并发：任务数大于CPU核心数，这就是并发执行
• 并行：任务数小于或等于CPU核心数，这就是并行执行

---

6.7. 自定义线程类

• 自定义线程类的步骤：

1. 创建类并且继承 threading.Thread

   class MyThread(threading.Thread):
     pass
   

2. 重写父类的run()方法

     def run(self):
     pass
   

3. 创建对象并且调用.start()

   mythread = MyThread()
   mythread.start()
   

• 自定义线程类的__init__方法问题

  # 子类先通过super()调用父类的run()方法,然后编写自己的代码
  def __init__(self,num):
      super().__init__()
      # 编写自己的代码
  

• 代码示例：

  import threading
  import time
  
  class MyThread(threading.Thread):
      """自定义线程类"""
      def __init__(self,num):
          super().__init__()
          self.num = num
  
      # 重写父类方法
      def run(self):
          for i in range(5):
              print("正在执行子线程的run方法……",i,self.name,self.num)
              time.sleep(0.5)
  
  if __name__ == '__main__':
      mythread = MyThread(23)
  
      mythread.start()
  

---

6.8. 多线程-共享全局变量

• 多线程之间可以共享全局变量

• 代码示例：

  import threading
  import time
  
  # 定义全局变量
  g_num = 0
  
  def work1():
      # 声明g_num是全局变量
      global g_num
      for i in range(10):
          g_num += 1
      print("work1-----",g_num)
  
  def work2():
      print("work2-----", g_num)
  
  if __name__ == '__main__':
      t1 = threading.Thread(target=work1)
      t2 = threading.Thread(target=work2)
  
      t1.start()
      t2.start()
  
      while len(threading.enumerate())!=1:
          time.sleep(1)
  
      print("main----",g_num)
  

---

6.9. 多线程-共享全局变量-问题

• 存在的问题：多线程同时访问同一个资源，出现资源竞争的问题

• 解决方法：优先让某个线程先执行

  线程对象.join()
  

• 缺点：把多线程变成单线程，影响整体性能

• 代码示例：

  import threading
  import time
  
  g_num = 0
  
  def work1():
      # 声明g_num是全局变量
      global g_num
      for i in range(1000000):
          g_num += 1
      print("work1-----",g_num)
  
  def work2():
      global g_num
      for i in range(1000000):
          g_num += 1
      print("work2-----", g_num)
  
  if __name__ == '__main__':
      t1 = threading.Thread(target=work1)
      t2 = threading.Thread(target=work2)
  
      t1.start()
      t1.join()
      t2.start()
  
      while len(threading.enumerate())!=1:
          time.sleep(1)
  
      print("main----",g_num)
  

---

6.10. 同步

• 同步：在多任务中，多任务之间的执行有先后顺序，一个执行完毕后，另一个再执行
• 异步：在多任务中，多任务之间的执行没有先后顺序，多个任务同时执行
• 线程的锁机制：当线程获取资源后，立刻进行锁定，资源使用完毕后再解锁，有效保证同一时间只有一个线程访问资源

---

6.11. 互斥锁

• 互斥锁使用过程：

  # 创建一把互斥锁
  lock = threading.Lock()
  
  # 加锁
  lock.acquire()
  
  要锁定的程序代码
  
  # 解锁
  lock.release()
  

• 代码示例：

  import threading
  import time
  
  g_num = 0
  
  def work1():
      global g_num
      lock.acquire()
      for i in range(1000000):
          g_num += 1
      lock.release()
      print("work1-----",g_num)
  
  def work2():
      global g_num
      lock.acquire()
      for i in range(1000000):
          g_num += 1
      lock.release()
      print("work2-----", g_num)
  
  if __name__ == '__main__':
      # 创建一把互斥锁
      lock = threading.Lock()
  
      t1 = threading.Thread(target=work1)
      t2 = threading.Thread(target=work2)
  
      t1.start()
      t2.start()
  
      while len(threading.enumerate())!=1:
          time.sleep(1)
  
      print("main----",g_num)
  
  

• 互斥锁的使用原则：尽可能少的锁定竞争资源

---

6.12. 死锁

• 死锁：在多线程中，两个线程都占用一些资源，而且同一时间都在等待对方释放资源，即为死锁状态
• 避免：锁使用完毕后就释放

• 代码示例：

  import threading
  
  def get_value(index):
      data_list = [1,3,5,7,9]
      lock1.acquire()
      if index >= len(data_list):
          print("下标越界",index)
          lock1.release()
          return
      print(data_list[index])
      lock1.release()
  
  if __name__ == '__main__':
  
      lock1 = threading.Lock()
  
      for i in range(10):
          t1 = threading.Thread(target=get_value,args=(i,))
          t1.start()
  

---

6.13. 案例：多任务版udp聊天器

• 代码示例：

  import socket
  import threading
  
  def send_msg(udp_socket):
      """发送信息"""
      # 接收方的IP地址
      ipaddr = input("请输入接收方的IP地址:\n")
      if len(ipaddr) is None:
          ipaddr = "192.168.70.1"
  
      # 接收方的端口号
      port = input("请输入接收方的端口号\n")
      if len(port) is None:
          port = 8080
  
      # 接收方的内容
      content = input("请输入要发送的内容\n")
  
      # 使用socket的sendto()发送信息
      udp_socket.sendto(content.encode("gbk"),(ipaddr,int(port)))
  
  def recv_msg(udp_socket):
      """接受信息"""
      # 使用socket接收数据
      while True:
          recv_data,ip_port = udp_socket.recvfrom(1024)
  
          # 解码数据
          recv_text = recv_data.decode()
          # 输出显示
          print("接收到[%s]的消息:%s" % (str(ip_port),recv_text))
  
  def main():
      """程序入口"""
      # 1.创建套接字
      udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
  
      # 2.绑定端口
      udp_socket.bind(("192.168.70.1",9090))
  
      # 创建子线程，单独接收用户发送的信息
      thread_recvmessage = threading.Thread(target=recv_msg,args=(udp_socket,))
      thread_recvmessage.setDaemon(True)
      thread_recvmessage.start()
  
      # 3.打印莱单（循环）
      while True:
          print("**************************************")
          print("************* 1.发送信息  *************")
          print("************* 2.退出系统  *************")
          print("**************************************")
  
          # 4.接收用户输入的选项
          sel_num = int(input("请输入选项：\n"))
  
          # 5.判断用户的选择,并且调用对应的函数
          if sel_num == 1:
              send_msg(udp_socket)
          elif sel_num == 2:
              print("系统正在退出……")
              print("系统退出完成")
              break
  
      # 6.关闭套接字
      udp_socket.close()
  
  if __name__ == '__main__':
      main()
  

---

6.14. TCP服务端框架

• tcp服务器

  1. 导入模块
  2. 创建套接字
  3. 设置地址可以重用
  4. 绑定端口
  5. 设置监听，套接字由主动设置为被动
  6. 接受客户端连接
  7. 接收客户端发送的信息
  8. 解码数据并进行输出
  9. 关闭和当前客户端的连接

• 支持多线程，思想：每进来一个新的客户端，创建一个新的线程

  # 接受客户端连接
  new_client_socket,ip_port = tcp_server_socket.accept()
  print("新用户上线",ip_port)
  
  # 创建线程
  thread_recvmsg = threading.Thread(target=recv_msg,args=(new_client_socket,ip_port))
  # 线程守护
  thread_recvmsg.setDaemon(True)
  # 线程开启
  thread_recvmsg.start()
  

• 代码示例：

  # 导入模块
  import socket
  import threading
  
  
  def recv_msg(new_client_socket , ip_port):
      while True:
          recv_data = new_client_socket.recv(1024)
          if recv_data:
              # 解码数据并且进行输出
              recv_text = recv_data.decode("gbk")
              print("收到来自[%s]的信息：%s" % (ip_port, recv_text))
          else:
              break
  
          # 关闭和当前客户端的连接
      new_client_socket.close()
  
  
  # 创建套接字
  tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  
  # 设置地址可以重用
  tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
  
  # 绑定端口
  tcp_server_socket.bind(("",8080))
  
  # 设置监听，套接字有主动设置为被动
  tcp_server_socket.listen(128)
  
  while True:
      # 接受客户端连接
      new_client_socket,ip_port = tcp_server_socket.accept()
      print("新用户上线",ip_port)
      # 接收客户端发送的信息
  
      thread_recvmsg = threading.Thread(target=recv_msg,args=(new_client_socket,ip_port))
      thread_recvmsg.setDaemon(True)
      thread_recvmsg.start()