python 多线程入门学习

import threading   # python 多线程包

# 定义一个处理的任务
def thread_job():
    print('This is an added Thread, numer is %s \n'% threading.current_thread())


def main():
    added_thread = threading.Thread(target = thread_job,name = 'T1')   # 添加一个线程 target是该线程要处理的任务(只需要写函数名，不用加括号) 
    added_thread.start()     # 启动该线程





print(threading.active_count())   # 打印当前激活的线程数
print(threading.enumerate())      # 打印当前激活的线程
print(threading.current_thread()) # 打印当前正在运行的线程

多线程 join()

import threading
import time

def thread_job():
    print( 'T1 start \n')
    time.sleep(1)
    print('T1 finish \n')
    
def T2_job():
    print('T2 start\n')
    print('T2 finish\n')

def main():
    added_Thread1 = threading.Thread(target = thread_job,name = 'T1')
    added_Thread2 = threading.Thread(target = T2_job,name = 'T2')
    added_Thread1.start()
    added_Thread2.start()
    added_Thread1.join()
    added_Thread2.join()
    
    print('all done\n')


没有 added_Thread1.join()和 added_Thread2.join()的输出：

T1 start 
T2 start
all done


T2 finish


T1 finish 

添加added_Thread1.join()和 added_Thread2.join()的输出：
T1 start 
T2 start

T2 finish


T1 finish 
all done


多线程同时运行，有的运行快，有的运行慢，如果想要执行完子线程的任务，再进行其他任务，需要添加.join()来等待子进程的完成

多线程队列

import threading
import time
from queue import Queue   #导入python队列模块

def job(l,q):
    for i in range(len(l)):
        l[i] = l[i] ** 2
    q.put(l)           # 将计算的结果放入到队列中

def multithreading():
    q = Queue()           # 定义一个队列
    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)


if __name__ == '__main__':
    multithreading()


[[1, 4, 9], [9, 16, 25], [16, 16, 16], [25, 25, 25]]

线程锁

 

当多个线程处理同一个内存地址时，多个线程同时进行，会相互影响。如果需要让第一个线程先处理完，再让第二个线程处理的话，需要使用线程锁.。

import threading 

def job1():
    global A
    for i in range(10):
        A += 1
        print('job1:%d\n'%A)

def job2():
    global A
    for i in range(10):
        A += 10
        print("job2: %d\n"%A)

if __name__ == '__main__':
    A = 0
    t1 = threading.Thread(target = job1)
    t2 = threading.Thread(target = job2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

无线程锁输出：
job1:1

job2: 11
job1:12 


job2: 30
job1:13


job2: 40
job1:14


job2: 50
job1:15


job2: 60
job1:16


job2: 70
job1:17


job2: 80
job1:18


job2: 90
job1:19


job2: 100
job1:20


job2: 110

 

import threading 

def job1():
    global A,lock    
    lock.acquire()    # 锁住这段程序
    for i in range(10):
        A += 1
        print('job1:%d\n'%A)
    lock.release()     #释放
    
def job2():
    global A,lock
    lock.acquire()
    for i in range(10):
        A += 10
        print("job2: %d\n"%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()


job1:1

job2: 20
job1:2


job2: 30
job1:3


job2: 40
job1:4


job2: 50
job1:5


job2: 60
job1:6


job2: 70
job1:7


job2: 80
job1:8


job2: 90
job1:9


job2: 100
job1:10


job2: 110

 

参考：

莫烦python

https://www.bilibili.com/video/av16944429