多线程监控队列执行 多线程执行任务

7.1 多任务

多任务介绍

• 同时做多件事情（多个任务）就叫多任务。

多任务理解

• 并发： CPU小于当前的执行的任务，是假的多任务
• 并行： CPU大于当前执行的任务，是真的多任务

实现多任务的三种方式

• 线程
• 进程
• 协程

7.2 线程

线程介绍

• 线程（thread）是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。

使用线程完成多任务

import time
import threading # 内置模块

def demo():
    print('hello world')
    time.sleep(1)
if __name__=='__main__':
   #  for i in range(3):
   #      demo()
   # '''
   # 循环一次 调用一次  再执行
   # 所以并不是同时执行的程序
   # '''

   for i in range(3):
       # 1.实例化线程
       t=threading.Thread(target=demo)  # 如果这里加括号 则是直接调用该函数 不是线程

       # 2.启动线程
       t.start()  # 注意 如果说没有进行 t.start() 则不会实现 target指定的函数

       '''
       线程实现多任务 同时调用demo() 函数
       '''

import time
import threading
def demo1():
    # print('wo shi demo1')

    for i in range(3):
        print('wo shi demo1')
        time.sleep(1)

def demo():
    for i in range(3):
        print('hello world')
        time.sleep(1)

        t1=threading.Thread(target=demo1)
        t1.start()
if __name__=='__main__':
    # t=threading.Thread(target=demo)
    # t.start()
    # print("--1--")
    '''
    当主线程执行完毕，但是仍然会等待子线程结束，主线程才会结束
    '''

    # t = threading.Thread(target=demo)
    # # 保护主线程  不会等子线程结束
    # t.setDaemon(True)
    # t.start()
    # print("--1--")

    # 等待子线程结束完毕，主线程再继续执行
    t = threading.Thread(target=demo)
    t.start()
    # t.join()
    print("--1--")

注意

• 主线程会等到子线程执行结束之后才主线程，才会结束

防护线程

• 守护线程，也就是说不会等子线程结束
• 使用方法:t.setDaemom(True)
• 那是可以实现子线程结束完毕，主线程才继续执行呢？
• 使用方法：t.join()

查看线程数量

• 使用thread.enumerate()来查看当前线程的数量。

import time
import threading

def demo1():
    for i in range(3):
        print(f'--demo1--{i}')
        time.sleep(1)

def demo2():
    for i in range(3):
        print(f'--demo2--{i}')
        time.sleep(1)

def main():
    t1=threading.Thread(target=demo1)
    t2=threading.Thread(target=demo2)

    t1.start()
    t2.start()

    # print(threading.enumerate())
    '''
    线程运行的时候  没有先后顺序 多次运行 会有细微的差别
    '''
    while True:
        print(threading.enumerate())
        if len(threading.enumerate()) <=1:
            break
        time.sleep(1)
if __name__=='__main__':
    main()

验证子线程的执行与创建

• 当调用Thread的时候，不会创建线程
• 当调用Thread创建出来的实例对象的start方法的时候，才会创建线程以及开始运行这个线程。

import time
import threading

def demo():
    for i in range(5):
        print('demo')

def main():
    print(threading.enumerate())
    t1=threading.Thread(target=demo)
    print(threading.enumerate())
    # 创建子线程 执行子线程
    t1.start()
    print(threading.enumerate())

if __name__=='__main__':
    main()

继承Thread类创建线程

import threading
import time

# 创建A类  继承Thread() 类
class A(threading.Thread):
    # 2.再类的内部重写 run (只能是run)
    def run(self):
        for i in range(3):
            self.demo()
            print(i)
            time .sleep(1)
    # 如果类里面有其它方法实现线程  在run 里面进行调用
    def demo(self):
        print("demo")

if __name__=="__main__":
    # 3.实例化类
    t=A()
    print(threading.enumerate())

    # 4.创建子线程  启动
    t.start()
    print(threading.enumerate())