python3多线程的运用

Python3线程

很大一堆数据需要处理，加速效率使用多线程可以节省运算的时间。

多线程基础

• threading.active_count() 目前多少个激活的线程

• threading.enumerate() 枚举当前正在运行的多线程

• threading.current_thread() 当前程序运行的进程是哪个线程

• 基本用法

  target  ： 指定 这个线程去哪个函数里面去执行代码

  args：     指定将来调用 函数的时候   传递什么数据过去

                  args参数指定的一定是一个元组类型
 name属性是命名多线程的名字
 start()是开始执行多线程
 join()是线程结束后再执行后来的语句才会用到

示例代码：

thread = threading.Thread(target=thread_job,)
thread.start()

thread_job函数是输出一个当前正在运行的线程名称，完整代码。

import threading

#def main():
#    print(threading.active_count())
#    print(threading.enumerate()) # see the thread list
#    print(threading.current_thread())

def thread_job():
    print('This is a thread of %s' % threading.current_thread())

def main():
    thread = threading.Thread(target=thread_job,)
    thread.start()
if __name__ == '__main__':
    main()

join应用

想要等待所有多线程运行完毕后再显示出all done\n，才需要用到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 T2_job(temp):
    print('T2 start\n')
    print("-----in test2 temp=%s-----"% str(temp))
    print('T2 finish\n')

def main():
    added_thread = threading.Thread(target=thread_job, name='T1')
    thread2 = threading.Thread(target=T2_job, args=(g_nums,), name='T2')
    added_thread.start()
    thread2.start()
    thread2.join()
    added_thread.join()

    print('all done\n')

if __name__ == '__main__':
    main()

Queue应用

多线程的结果是没有返回值的，可以把所有线程结果放到长队列中运算然后再取出来。

import threading
import 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):       # 定义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):       # 从4个线程里面得到结果，按顺序拿出结果
          results.append(q.get())
    print(results)

if __name__ == '__main__':
    multithreading()

GIL

Python不是真正意义上的多线程而是在多个线程中快速切换。

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)

lock

第一个线程处理完结果，然后第二个线程用的时候。会用到锁，在第一个线程处理时，第二个线程暂时无法操作。等第一个线程执行完毕之后才可以接下来的操作。

A是一个全局变量，当两个线程对同一个变量进行操作。那么就在操作A的时候锁住其他线程。然后当操作完毕之后再让第二个线程操作。

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()

参考

https://www.bilibili.com/video/av16944429/?p=5

https://github.com/MorvanZhou/tutorials/tree/master/threadingTUT