python高级编程之线程

https://blog.csdn.net/weixin_45912307/article/details/109084315

1.线程概念

线程是进程中执行代码的一个分支，线程是cpu调度基本单位。 线程是Python程序中实现多任务的另外一种方式，线程的执行需要cpu调度来完成

2. 线程语法

1. 导入线程模块
import threading
2. 线程类Thread参数说明
Thread([group [, target [, name [, args [, kwargs]]]]])

 group: 线程组，目前只能使用None
target: 执行的目标任务名
args: 以元组的方式给执行任务传参
kwargs: 以字典方式给执行任务传参
name: 线程名，一般不用设置

3. 多线程基本使用

import random
import threading


# 1. 创建线程
def task1():
    # 获取当前线程
    current_threading = threading.current_thread()
    print('task1_tid:', current_threading)
    for i in range(random.randint(11, 100)):
        print(i)


def task2():
    current_threading = threading.current_thread()
    print('task2_tip:', current_threading)
    for i in range(random.randint(0, 10)):
        print(i)


if __name__ == '__main__':
    # 主线程
    main_thread = threading.current_thread()
    print('主线程：', main_thread)
    # 2. 创建子进程
    sub_thread1 = threading.Thread(target=task1, name='任务1')
    sub_thread2 = threading.Thread(target=task2, name='任务2')
    # 3. 启动子线程执行对应的任务
    sub_thread1.start()
    # 让当前线程(主线程)等待task1(任务1)子线程执行完成以后代码再往下执行
    sub_thread1.join()
    sub_thread2.start()

4. 线程执行带有参数的任务

1. 以元组方式,保证元组元素顺序和函数参数顺序一致
2. 以字典方式，保证key和value对应

参考进程创建:https://blog.csdn.net/weixin_45912307/article/details/109079998

5. 解决：主线程等待所有子线程执行结束再结束

1. 法1：
daemon=True 创建的子线程守护主线程，主线程退出子线程直接销毁

2. 法2：

# 法2：把子线程设置为守护主线程
    sub_thread = threading.Thread(target=task1)
    sub_thread.setDaemon(True)
    sub_thread.start()

import random
import time
import threading


def task1():
    while True:
        for i in range(random.randint(1, 100)):
            print(i)


if __name__ == '__main__':
    # 创建子线程
    # 法1：1. daemon=True 创建的子线程守护主线程，主线程退出子线程直接销毁
    # sub_thread = threading.Thread(target=task1,daemon=True)

    # 法2：把子线程设置为守护主线程
    sub_thread = threading.Thread(target=task1)
    sub_thread.setDaemon(True)
    sub_thread.start()

    # 主线程延时1s
    time.sleep(0.5)
    print('over')


主线程等待所有子线程执行结束再结束

6 继承threading.Thread重写run方法

import datetime
import threading
import logging

logging.basicConfig(level=logging.INFO)


class MyThring(threading.Thread):
    def __init__(self, func, args, name=''):
        super(MyThring, self).__init__()
        self.func = func
        self.args = args
        self.name = name

    def run(self):  # 重写run方法
        self.func(*self.args)


def task(ntask, nesc):
    # 任务
    start_time = datetime.datetime.now()
    logging.info("start task->(%s) time: %s" % (ntask, start_time))
    sum([i for i in range(nesc)])
    end_time = datetime.datetime.now()
    logging.info('end   task->(%s) time: %s' % (ntask, end_time))


def main(task_list):
    threads = []
    logging.info('start all time:  \t\t%s' % datetime.datetime.now())
    task_len = range(len(task_list))  # 任务列表长度
    for i in task_len:
        t = MyThring(task, (i, task_list[i]), task.__name__)
        threads.append(t)  # 把任务追加到线程列表
    for i in task_len:
        threads[i].start()  # 启动线程
    for i in task_len:
        threads[i].join()  # 等待子进程执行结束，阻塞
    logging.info('end   all time:  \t\t%s' % datetime.datetime.now())


if __name__ == '__main__':
    task_list = [10000, 1000000, 500, 100000000]
    main(task_list)

小结：

1. 线程之间运行无序，具体哪个线程先执行有cpu调度决定的
2. 操作系统操作进程，cpu操作线程
3. 一个进程里有多个线程，线程之间共享全局变量
4. 主线程等待所有子线程执行结束再结束