Python多线程threading

wklken的笔记

2019-12-30

介绍

在Python中，使用多线程multi-threading可以『同时』执行多个任务，比如你需要一个线程来复制读取信息，另一个线程来解析。为什么这里的同时要加引号呢，这是由于Python中GIL，也就是全局锁，看似同时执行多个任务，实际上是分布执行的，只不过各自完成不同的任务会提高工作效率。如果你不了解GIL，请看下图
Python多线程threading

实例教程

实例1

import threading

def job():
    info = "this is an added thread, which is %s" % threading.current_thread
    print(info)

def main():
    print(threading.active_count())
    print(threading.enumerate())
    #print(threading.current_thread())

    # 创建一个Thread对象，让他来复制job任务
    new_thread = threading.Thread(target=job)
    # 执行线程任务
    new_thread.start()
    print(threading.active_count())

if __name__ == '__main__':
    main()

运行结果：

1
[<_MainThread(MainThread, started 140637982934784)>]
this is an added thread, which is <function current_thread at 0x7fe8cd92d378>
2

解释一下：

threading是线程模块，需要导入
threading.active_count()方法会给出所有激活的线程数量
threading.enumerate()方法会列举出存在的每一个线程
threading.current_thread()方法会给出当前正在执行的线程
使用时需要先创建线程对象，并指定任务（target），然后用start方法来执行

实例2

import threading
import time

def job():
    print('T1 start\n')
    # 让任务延迟一下
    for i in range(10):
        time.sleep(0.1)
    print('T1 finish\n')

def job2():
    print('T2 start\n')
    # 任务不延迟
    print('T2 finish\n')

def main():
    thread1 = threading.Thread(target=job,name='T1')
    thread2 = threading.Thread(target=job2,name='T2')
    thread1.start()
    thread2.start()

    #thread1.join()

    print('all done')

if __name__ == '__main__':
    main()

运行结果：

T1 start

T2 start

T2 finish

all done
T1 finish

会发现all done并不是在最后执行的，怎么办呢？试试把join方法解除封（注）印（释），请看结果：

T1 start

T2 start

T2 finish

T1 finish

all done

解释一下：

多个线程是交叉进行的
join方法可以用来等待该线程完成任务

实例3

import threading
from queue import Queue
import time

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

    q.put(l)


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

    print(results)

def unithreading(data):
    for i in range(len(data)):
        l = data[i]
        for j in range(len(l)):
            data[i][j] = data[i][j]**2

    print(data)

if __name__ == '__main__':
    data1 = [[1],[2,3],[4,5,6],[7,8,9,10]]
    data2 = [[1],[2,3],[4,5,6],[7,8,9,10]]
    time1 = time.clock()
    unithreading(data1)
    time2 = time.clock()
    multithreading(data2)
    time3 = time.clock()

    runtime_uni = time2 - time1
    runtime_multi = time3 - time2

    print("Runtime for unithreading is %s seconds." % runtime_uni)
    print("Runtime for multithreading is %s seconds." % runtime_multi)

运行结果：

[[1], [4, 9], [16, 25, 36], [49, 64, 81, 100]]
[[1], [4, 9], [16, 25, 36], [49, 64, 81, 100]]
Runtime for unithreading is 4.300000000000137e-05 seconds.
Runtime for multithreading is 0.001118000000000001 seconds.

解释一下：

这个例子主要是对比一下单线程是多线程的速度
这里演示了如何创建多个线程（此处为4个），并且分别执行任务
因为线程任务本身是没有return的，所以顺便学习一下队列queue的用法，以及put和get方法

实例4

import threading


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

def job2():
    global A
    #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()

运行结果：

job1job2  111

job1job2  1222

job1job2  2333

job1job2  3444

job1job2  4555

job1job2  5666

job1job2  6777

job1job2  7888

job1job2  8999

job1job2  100110

你会发现这打印得错乱了，这也是多个线程交替工作得原因，如果先想要规定一个线程工作的时候防止别的线程干扰，需要怎么做呢？试试使用lock（注释部分）吧，再运行一下：

job1 1
job1 2
job1 3
job1 4
job1 5
job1 6
job1 7
job1 8
job1 9
job1 10
job2 20
job2 30
job2 40
job2 50
job2 60
job2 70
job2 80
job2 90
job2 100
job2 110

解释一下：