知识点-多线程threading（Thread，join，qunue和lock功能）

1.创建多线程Thread

import threading

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

def main():
    add_thread=threading.Thread(target=thread_job) #添加创建线程，并给他工作
    add_thread.start()#添加线程开始
    print(threading.active_count()) #查看当前线程数
    print(threading.enumerate())#查看当前线程名称
    print(threading.current_thread())#查看当前运行线程

if __name__ =="__main__":
    main()

2.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():
    add_thread=threading.Thread(target=thread_job,name="t1") #添加线程，并给他工作,name是命名
    thread2=threading.Thread(target=t2_job,name="t2") #添加另外线程，并给他工作,name是命名
    add_thread.start()#添加线程开始
    thread2.start()
    add_thread.join()#添加join了就必须上面线程干完活了才执行join后面的
    thread2.join()#添加join了就必须上面线程干完活了才执行join后面的
    print("all done\n")

if __name__ =="__main__":
    main()

3.qunue队列，用它来出来接收线程的处理值

import time
from queue import Queue

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

def multithreading():
    q=Queue()  #正常多线程没有返回值，需要用q来替换
    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))#target是传检索所以job没括号，传值用args传
        t.start()
        threads.append(t)
    for thread in threads:#有几次就需要关闭几次join
        thread.join()
    results=[]
    for i in range(4): #有几次就需要拿几次q
        results.append(q.get())
    print(results)

if __name__ =="__main__":
    multithreading()

4.lock全局锁，可以锁住一个线程，一个线程在多个时间段传值

import  threading

def job1():
    global A,lock #全局变量
    lock.acquire() #lock acquire和release就是锁住
    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(target=job1) #分布两个线程两个工作
    t2=threading.Thread(target=job2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()