Python基础（一）：threading多线程

红毛乌龟

已于 2023-05-05 13:39:46 修改

阅读量3.5k

点赞数 5

分类专栏： Python 文章标签： python

于 2023-04-29 22:45:05 首次发布

本文链接：https://blog.csdn.net/daishabby2486/article/details/130443898

版权

Python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、什么是多线程

多线程threading就是同时间、分批量安排Python去做很多东西，这样可以大大地节省计算的时间。

二、添加线程

导入threading包

import threading

2.1 threading常用方法

threading.active_count()

查询已有的线程thread的个数

threading.enumate()

查看已有的线程

threading.current_thread()

查看正在运行的线程

运行结果展示：

2.2 添加thread

import threading


def thread_job():
    print('This is an added Thread, which is %s' % threading.current_thread())


def main():
    # 添加一个线程
    added_thread = threading.Thread(target=thread_job)  # target表示要该线程要执行的任务
    # 启动线程
    added_thread.start()


if __name__ == '__main__':
    main()

运行结果：

三、join功能

join方法的作用是确保thread子线程执行完毕后才能执行下一个线程。

- 不使用join方法的情况：

import threading
import time


def thread_job():
    print('T1 start\n')
    for i in range(10):
        # time.sleep() 函数推迟调用线程的运行，可通过参数secs指秒数，表示进程挂起的时间。
        time.sleep(0.1)
    print('T1 finish\n')


def main():
    added_thread = threading.Thread(target=thread_job, name='T1')
    added_thread.start()
    print('all done\n')


if __name__ == '__main__':
    main()

运行结果：

这是因为，main()是一个线程，added_thread()也是一个线程，多线程运行时，main()不会等待added_thread()结束以后再运行。

- 加入join的情况：

import threading
import time


def thread_job():
    print('T1 start\n')
    for i in range(10):
        time.sleep(0.1)
    print('T1 finish\n')


def main():
    added_thread = threading.Thread(target=thread_job, name='T1')
    added_thread.start()
    # 确保added_thread子线程执行完毕后才能执行下一个线程
    added_thread.join()
    print('all done\n')


if __name__ == '__main__':
    main()

运行结果：

四、Queue功能

queue 模块即队列，特别适合处理信息在多个线程间安全交换的多线程程序中。

import threading
from queue import Queue


arr = [[1, 1, 2], [2, 3, 4], [2, 3, 2], [1, 4, 5]]


def job(number, q):
    for i in range(len(number)):
        number[i] = number[i] ** 2
    q.put(number)


def multithreading(data):
    q = Queue()
    threads = []
    for i in range(4):
        t = threading.Thread(target=job, args=(data[i], q))
        t.start()
        threads.append(t)
    for thread in threads:
        thread.join()
    result = []
    for _ in range(4):
        result.append(q.get())
    print(result)


if __name__ == '__main__':
    multithreading(arr)

运行结果：

五、不一定有效率

多线程的工作原理：

import threading
from queue import Queue
import copy
import time


def job(l, q):
    res = sum(l)
    q.put(res)


def multithreading(l):
    q = Queue()
    threads = []
    for i in range(4):
        t = threading.Thread(target=job, args=(copy.copy(l), q), name='T%i' % i)
        t.start()
        threads.append(t)
    [t.join() for t in threads]
    total = 0
    for _ in range(4):
        total += q.get()
    print(total)


def normal(l):
    total = sum(l)
    print(total)


if __name__ == '__main__':
    l = list(range(1000000))
    s_t = time.time()
    normal(l*4)
    print('normal: ',time.time()-s_t)
    s_t = time.time()
    multithreading(l)
    print('multithreading: ', time.time()-s_t)

运行结果：

六、锁

import threading


def job1():
    global A, lock
    lock.acquire()
    for i in range(10):
        A += 1
        print('job1', A)
    lock.release()


def job2():
    global A, lock
    lock.acquire()
    for i in range(10):
        A += 10
        print('job2', A)
    lock.release()


if __name__ == '__main__':
    lock = threading.Lock()
    A = 0
    t1 = threading.Thread(target=job1)
    t2 = threading.Thread(target=job2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

运行结果：