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\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():
     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\n')

注释掉 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\n")

"""
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/