Python3多线程学习

一、简单实现多线程的方法

使用继承的方式实现多线程

import threading


class myTread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        pass

if __name__ == '__main__':
    mythread = myTread()
    mythread.start()

二、配合queue多线程实现同步

实现打印10000000个数字的方式对单线程和多线程进行对比，实现代码如下

import threading
import queue
import time

class myTread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):
        while not q.empty():
            print(q.get_nowait()) #从队列中取数据，并打印输出
            q.task_done()         #判断单条get是否取完毕


if __name__ == '__main__':
    q = queue.Queue()
    #先把数据放入队列中
    for i in range(1000000):
        q.put(i)
    #设置开始时间
    start_time = time.time()
    for i in range(7):
        t1 = myTread()
        t1.start()

    q.join() #判断队列是否已经取完，没取完之前就会就行线程堵塞
    end_time = time.time()
    # print('时间：{}'.format((end_time - start_time)))  #计算程序运行时间
    print(f'时间：{end_time - start_time}')

单线程运行时间：

多线程运行时间，这个我开7个线程：

发现反而是单线程的执行效率比多线程的快好多。

Python中对GIL的理解：

Python是解释型语言，那么它在运行的时候就需要解释器了，简单描述下GIL，即global interpreter lock，全局解释器锁，就是python在运行的时候会锁定解释器，就是说在运行的时候只能是一个线程，锁死了，切换不了；每个线程在运行之前都要申请GIL，那么就必须要等上一个线程释放这把锁你才可以申请到，然后执行代码，执行完后，你再交给下一个线程，让它去执行代码，所以多线程会频繁的竞争得到GIL，固然要比单线程的时间多，过程如下：

　　设置GIL -> 切换到一个线程去执行 -> 运行 -> 把线程设置为睡眠状态 -> 解锁GIL

总结

Python的多线可以大幅提高代码的效力，但是对于人工智能来说就不太适合了，所以数据领域没有多线程提高效率之说，只有将CPU提升到GPU，TPU来提升计算能力。

Python多现实适合于IO密集型任务：

比如爬虫，当向服务器发送请求的时候，要等服务器响应返回数据，程序才会释放GIL锁，进程才会往下执行，如果是单线程的话，每一次请求都要等待前面的进程访问时间，每次请求服务器返回的数据时间都不一样，如果每次请求都要排队等待的话，反而时间会更长，那么单线程显而易见反而效力底下，如果多线程的话就是实现并发请求，反而效力更高

参考博客：

Python3 多线程为啥比单线程优秀_奋力的小白的博客-CSDN博客

python多线程比单线程效率低_多线程比单线程快，是真的吗？_weixin_39800971的博客-CSDN博客

三、Python实现线程池

Python简单实现线程池代码如下所示

import queue
from concurrent.futures import ThreadPoolExecutor, as_completed

q = queue.Queue()
data_list = [1,2,3,4,5,6,7,8,9,10]
for i in data_list:
    q.put(i)

# 开启线程池 max_workers表示支持的最大线程数
with ThreadPoolExecutor(max_workers=17) as t:
    relt_list = []
    while not q.empty():
        agrs = q.get()
        rest = t.submit(g_t_main, agrs)
        q.task_done()
        relt_list.append(rest)
    # 判断单个线程是否执行完毕
    for future in as_completed(relt_list):
        data = future.result()
        print(f"main: {data}")

线程池可以有效的防住线程堵塞和资源竞争问题，优化线程池使用代码如下所示

import concurrent.futures
import queue
from concurrent.futures import ThreadPoolExecutor, as_completed

q = queue.Queue()
data_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for i in data_list:
    q.put(i)


def g_t_main(s):
    return s

# 开启线程池 max_workers表示支持的最大线程数
with ThreadPoolExecutor(max_workers=3) as t:
    all_task = []
    while not q.empty():
        all_task.append(t.submit(g_t_main, q.get()))
    concurrent.futures.wait(all_task)
    # 判断整个线程是否执行完毕
    for future in as_completed(all_task):
        data = future.result()
        print(f"main: {data}")