添加add threading
import threading
def main():
added_thread=threading.Thread(target=thread_job) #添加线程
added_thread.start() #运行添加的线程
print(threading.active_count()) #输出有多少个激活了的线程
print(threading.enumerate()) #输出激活了的线程的名称
print(threading.current_thread()) #正在运行的线程
def thread_job():
print('This is an added Thread,number is %s'% threading.current_thread())
join功能
1. 阻塞主进程，专注于执行多线程中的程序。
2. 多线程多join的情况下，依次执行各线程的join方法，前头一个结束了才能执行后面一个。
3. 无参数，则等待到该线程结束，才开始执行下一个线程的join。
4. 参数timeout为线程的阻塞时间，如 timeout=2 就是罩着这个线程2s 以后，就不管他了，继续执行下面的代码。
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") #添加线程，命名为T1
thread2=threading.Thread(target=T2_job,name="T")
added_thread.start()
thread2.start()
added_thread.join() #要等待added_thread运行完了后才运行join之后的命令
thread2.join()
print('all done\n')
Queue功能
多线程无返回值，所以运算结果要放在一个长队列当中，对每一个线程的队列到主线程后再拿出来继续加算。
import threading
import time
from queue import Queue
def job():
for i in range(len(l)):
l[i]=l[i]**2
q.put(l)
def multithreading(data):
q=Queue() #定义Q,之后在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()
results=[]
for_ in range(4):
results.append(q.get()) #按顺序拿出一个
print(results)
不一定有效率
多线程有一个全局的控制，其实并不是把任务平均分给每个人同时在做这个任务。他是GIL让程序把线程锁住，只有唯一一个线程在运算，然后不停地切换。其实只是节约了读写的时间，当读写的时候可以开始第二个线程。
当两个线程没有太大关系时可能有效果。如果是处理同一个data，然后用多线程分步来做，就没什么用了。
Lock锁
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()
if_name_:'_main_':
lock=threading.Lock()
A=0
t1=threading.Thread(targe=job1)
t2=threading.Thread(targe=job2)
t1=start()
t2=start()
t1.join()
t2.join()