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

查看thread信息

1 import threading
2 print(threading.current_thread())
3 print(threading.enumerate())
4 print(threading.active_count())

定义thread job并开启

1 def thread_job():
2     print("this is added thread,number is %s"%(threading.current_thread()))
3 
4 added_thread = threading.Thread(target=thread_job)
5 added_thread.start()

join()的功能

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

 1 import threading
 2 import time
 3 def thread_job():
 4     print('T1 start\n')
 5     for i in range(10):
 6         time.sleep(0.1)
 7     print('T1 Finish\n')
 8     
 9 def T2_job():
10     print('T2 start\n')
11     print('T2 Finish\n')
12 
13 
14 def main():
15     added_thread = threading.Thread(target=thread_job,name='T1')
16     thread2 = threading.Thread(target=T2_job,name='T2')
17     added_thread.start()
18     thread2.start()
19     thread2.join()
20     added_thread.join()
21     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存储数据

 1 from queue import Queue
 2 import threading
 3 import time
 4 
 5 def job(l,q):
 6     for i in range(len(l)):
 7         l[i] = l[i]**2
 8     q.put(l)
 9 
10 def multithreading():
11     q =Queue()    #q中存放返回值，代替return的返回值
12     threads = []
13     data = [[1,2,3],[3,4,5],[4,4,4],[5,5,5]]
14     for i in range(4):
15         t = threading.Thread(target=job,args=(data[i],q))
16         t.start()
17         threads.append(t)
18     for thread in threads:
19         thread.join()
20     res = []
21     for _ in range(4):
22         res.append(q.get())
23     print(res)
24 
25 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()将锁打开， 保证其他的线程可以使用该共享内存。

 1 def job1():
 2     global A ,lock
 3     lock.acquire()
 4     for i in range(10):
 5         A+=1
 6         print('job1',A)
 7     lock.release()
 8 def job2():
 9     global A ,lock
10     lock.acquire()
11     for i in range(10):
12         A+=10
13         print('job2',A)
14     lock.release()
15 
16 def job1():
17     global A
18     for i in range(10):
19         A+=1
20         print('job1',A)
21    
22 def job2():
23     global A
24     for i in range(10):
25         A+=10
26         print('job2',A)
27 
28 A = 0
29 lock = threading.Lock()
30 t1 = threading.Thread(target=job1)
31 t2 = threading.Thread(target=job2)
32 t1.start()
33 t2.start()
34 t2.join()
35 t1.join()

参考：

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

python ---thread