Python内置多线程模块threading笔记

参考链接：https://www.bilibili.com/video/BV1jW411Y7Wj

基础使用：

添加线程，开启线程，打印当前线程，当前开启线程数

import threading

def thread_job():
    print(f'This is an added Thread, number is {threading.current_thread()}')

def main():
    threading.Thread(target=thread_job).start()
    print(threading.active_count())
    print(threading.enumerate())
    print(threading.current_thread())

if __name__ == '__main__':
    main()

运行结果：

This is an added Thread, number is <Thread(Thread-1, started 2040)>
2
[<_MainThread(MainThread, started 8768)>, <Thread(Thread-1, started 2040)>]
<_MainThread(MainThread, started 8768)>

Process finished with exit code 0

观察同时运行：

import threading, time

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

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

if __name__ == '__main__':
    main()

运行结果：
T1 start
all done


T1 finish


Process finished with exit code 0

1. 没等添加的线程运行完，"all done"就打印出来了。
2. 细节：print”all done\n“的主线程在新线程打印出”T1
   start\n“后，print函数默认（print(str,sep=’\n’）)结尾会加一个换行，而 all done 在换行前打印了出来。
   所以打印结果中 all done 下面的3个换行：
   第一个是 print(“T1 start\n”) 函数的默认换行；
   第二个是”“all done\n"中的换行；
   第三个是print(“all done\n”)函数的默认换行；

thread.join()方法

import threading, time

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

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

if __name__ == '__main__':
    main()

运行结果：
T1 start

T1 finish

all done


Process finished with exit code 0

上面main函数里修改了一下：
线程对象的.join()方法：可以让选中的线程优先完成，才返回主线程继续工作。

再增加一个线程看看

import threading, time

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

def T2_job():
    print('T2 start\n')
    print('T2 finish\n')

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

if __name__ == '__main__':
    main()

运行结果：
T2 start

T2 finish

T1 start

all done

T1 finish


Process finished with exit code 0

线程2运算时间短，快速的完成了。居然比先开始运行的线程1更快，然后因为线程1没有设置join的优先，主线程会比需要sleep的线程1先完成。

4线程计算

import threading, time
from queue import Queue

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

def multithreading():
    q = Queue()
    threads = []
    data = [[1, 2, 3], [3, 4, 5], [4, 4, 4], [5, 5, 5]]
    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()
    results = []
    for _ in range(4):
        results.append(q.get())
    print(results)

if __name__ == '__main__':
    multithreading()

运算结果：
[[1, 4, 9], [9, 16, 25], [16, 16, 16], [25, 25, 25]]

Process finished with exit code 0

运行效率不一定高

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)

运行结果：
1999998000000
normal:  0.1042778491973877
1999998000000
multithreading:  0.10628461837768555

copy.copy：潜复制，如果不要这部，直接调用生成的l,那么多线程速度会快些。我的cpu是i7.