python ---多线程thread

thread 在数据预处理的时候用处不大，因为有GIL 锁

查看thread信息

import threading
print(threading.current_thread())
print(threading.enumerate())
print(threading.active_count())

定义thread job并开启

def thread_job():
    print("this is added thread,number is %s"%(threading.current_thread()))

added_thread = threading.Thread(target=thread_job)
added_thread.start()

join()的功能

 先运行join的功能，然后再运行join 下面的。

import threading
import time
def thread_job():
    print('T1 start
')
    for i in range(10):
        time.sleep(0.1)
    print('T1 Finish
')
    
def T2_job():
    print('T2 start
')
    print('T2 Finish
')


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()
    added_thread.join()
    print('all done
')

注释掉 19、20

你也可以添加thread_2.join()进行尝试，但为了规避不必要的麻烦，推荐如下这种1221的V型排布：

thread_1.start() # start T1
thread_2.start() # start T2
thread_2.join() # join for T2
thread_1.join() # join for T1
print("all done
")

"""
T1 start
T2 start
T2 finish
T1 finish
all done
"""

利用Queue存储数据

from queue import Queue
import threading
import time

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

def multithreading():
    q =Queue()    #q中存放返回值，代替return的返回值
    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()
    res = []
    for _ in range(4):
        res.append(q.get())
    print(res)

multithreading()

GIL锁

Global Interpreter Lock (GIL). 这个东西让 Python 还是一次性只能处理一个东西.

尽管Python完全支持多线程编程， 但是解释器的C语言实现部分在完全并行执行时并不是线程安全的。 实际上，解释器被一个全局解释器锁保护着，它确保任何时候都只有一个Python线程执行。 GIL最大的问题就是Python的多线程程序并不能利用多核CPU的优势 （比如一个使用了多个线程的计算密集型程序只会在一个单CPU上面运行）。

在讨论普通的GIL之前，有一点要强调的是GIL只会影响到那些严重依赖CPU的程序（比如计算型的）。 如果你的程序大部分只会涉及到I/O，比如网络交互，那么使用多线程就很合适， 因为它们大部分时间都在等待。实际上，你完全可以放心的创建几千个Python线程， 现代操作系统运行这么多线程没有任何压力，没啥可担心的。

线程锁 Lock

lock在不同线程使用同一共享内存时，能够确保线程之间互不影响，使用lock的方法是， 在每个线程执行运算修改共享内存之前，执行lock.acquire()将共享内存上锁，
 确保当前线程执行时，内存不会被其他线程访问，执行运算完毕后，使用lock.release()将锁打开， 保证其他的线程可以使用该共享内存。

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

def job1():
    global A
    for i in range(10):
        A+=1
        print('job1',A)
   
def job2():
    global A
    for i in range(10):
        A+=10
        print('job2',A)

A = 0
lock = threading.Lock()
t1 = threading.Thread(target=job1)
t2 = threading.Thread(target=job2)
t1.start()
t2.start()
t2.join()
t1.join()

参考：

https://morvanzhou.github.io/tutorials/python-basic/threading/6-lock/