首页 > 编程语言> > ＜Notes＞Python_Multithreading

＜Notes＞Python_Multithreading

2021-03-04 23:30:11 作者：互联网

＜Notes＞Python_Multithreading

前言
学习笔记
其他思考
学习总结
参考资料

前言

基本学习目标

学习Python多线程基本语法
巩固Python编程知识
实际设计：设计多线程收发通信程序

学习笔记

theading核心函数大致用法

添加线程：

代码如下：

import threading

def thread_job():
    #查看运行当前程序的线程
    print('This is a thread of %s \n'%threading.current_thread())   # \反斜杠，/正斜杠
    #查看当前线程数
    print(threading.active_count())

def main():
    t1 = threading.Thread(target = thread_job)
    t1.start()
    #print(threading.active_count())  这行代码不能放在这，因为主线程和t1线程不知道谁执行的快，所以有时输出1有时输出2

if __name__ == '__main__':
    main()
    
 #output:
	This is a thread of <Thread(Thread-1, started 1028)> 
	2

join函数：

功能描述：控制线程执行
用法描述：在线程1中对线程2使用join方法，线程1会停在此处等待线程2执行完成之后再执行；
代码分析：

import threading
import time

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

def t2_job():
    print('t2 start\n')
    print('t2 finish\n')

def main():
    t1 = threading.Thread(target=t1_job,name='t1')   #这里如果函数加（），程序会先执行一遍函数
    t2 = threading.Thread(target=t2_job,name='t2')
    t1.start()
    t2.start()
    t1.join()
    t2.join()

    print('all done\n')

if __name__ == '__main__':
    main()

Queue功能：

功能描述：多线程的运算结果是不能有返回值的，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)   #put是Queue的方法

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

if __name__ == '__main__':
    multthreading()

GIL机制：

问题描述：GIL（Global Interpreter Lock），一个时间只有一个线程在运算；

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once.
This lock is necessary mainly because CPython’s memory management is not thread-safe.
(However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

在这里插入图片描述

代码分析：

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)

结果分析：

输出：normal: 0.15059614181518555 multithreading: 0.14162278175354004

分析：为什么节约了一点点时间？扣除了读写(IO)的时间，

单线程下有 IO操作会进行 IO等待，造成不必要的时间浪费，而开启多线程能在线程 A等待时，自动切换到线程 B，可以不浪费 CPU的资源，从而能提升程序执行效率；

python中想要某个线程要执行必须先拿到 GIL这把锁，且 python只有一个 GIL，拿到这个 GIL才能进入 CPU执行，在遇到 I/O 操作时会释放这把锁。如果是纯计算的程序，没有 I/O 操作，解释器会每隔 100次操作就释放这把锁，让别的线程有机会执行（这个次数可以通sys.setcheckinterval来调整）。所以虽然 CPython 的线程库直接封装操作系统的原生线程，但 CPython 进程做为一个整体，同一时间只会有一个获得了 GIL 的线程在跑，其它的线程都处于等待状态等着 GIL 的释放。

总结：进行 IO密集型的时候可以进行分时切换所有这个时候多线程快过单线程

lock用法：

功能描述：对于多个线程同时需要访问一个变量，lock可以控制锁住变量，（线程）不互相干扰
用法描述：mutex = threading.Lock() # 创建锁mutex.acquire([timeout]) # 锁定mutex.release() # 释放

代码分析：

import threading
import time

def job1():
    time.sleep(5)
    global A,lock
    lock.acquire()

    for i in range(10):
        A += 1
        print('job',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()

结果分析：