python单核多线程

#1、多线程函数
import threading
threading.active_count() #当前正在激活的线程有几个
threading.enumerate();#当前正激活的线程集合
threading.current_thread();#当前位置是被哪个线程在跑

#2、基本使用
import threading
from time import sleep

def test():
    print("start \n" )
    sleep(1)
    print("end\n")
def test2():
    print("start2\n")
    print("end2\n")

def main():
    add_thread = threading.Thread(target=test,name='thread1') #name线程名字，tartget要做的事情
    add_thread2 = threading.Thread(target=test2,name='thread2') #name线程名字，tartget要做的事情
    add_thread.start()    
    add_thread2.start()
    add_thread.join() #当前进程完成后才会执行后续操作
    add_thread2.join()#当前进程完成后才会执行后续操作 ,1与2 同时进行，虽然2在1后面执行，但是2用时少 ，先完成
    print("all done\n")

if __name__ == '__main__':
    main() 


#3、多线程处理数据
import threading
from queue import Queue

#任务函数
def computed(datalist,q):
    for key in range(len(datalist)):
        datalist[key] = datalist[key] ** 2
    q.put(datalist)
#主函数
def  main():
    q = Queue()
    data = [[1,2,3],[2,3,4],[3,4,5],[4,5,6]]
    threadList = []
    for i in range(4):
        t = threading.Thread(target = computed,args=(data[i],q))
        t.start()
        threadList.append(t)

    for thread in threadList:
        thread.join()

    result = []
    for datalist in range(4):
        result.append(q.get())

    print(result)

if __name__ == '__main__':
    main() 


#4、锁（线程一整个单元执行完以后，线程二才执行否则等待）

import threading
from queue import Queue


def jobOne():
    global A,lock
    lock.acquire()
    for i in range(10):
        A += 1
        print('jobOne',A)
    lock.release()

def jobTwo():
    global A,lock
    lock.acquire()
    for i in range(10):
        A += 10
        print('jobTwo',A)
    lock.release()

def main():
    tOne = threading.Thread(target = jobOne)
    tTwo = threading.Thread(target = jobTwo)
    tOne.start()
    tTwo.start()
    tOne.join()
    tTwo.join()
    print('all end')

if __name__ == '__main__':
    A = 0
    lock = threading.Lock()
    main()
    
    
#5、threading.local：声明多线程内部的局部变量，各个线程之间的变量不影响

import threading
# 创建全局 ThreadLocal 对象:
local_school = threading.local()

def process_student():
     # 获取当前线程关联的 student:
     std = local_school.student
     print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):
     # 绑定 ThreadLocal 的 student:
     local_school.student = name #每个local_school.student都是独立的
     process_student()

t1 = threading.Thread(target= process_thread, args=('Alice',),
name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('Bob',),
name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()