python多线程threading

最新推荐文章于 2024-07-01 14:37:15 发布

a尼

最新推荐文章于 2024-07-01 14:37:15 发布

阅读量104

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/m0_56094505/article/details/118224242

版权

python 专栏收录该内容

24 篇文章 4 订阅

订阅专栏

碎碎念

在学习python的多线程之前我一直很纳闷多线程有什么用？毕竟学习一门东西你知道了它的用途了之后就更加有动力去学习它

然后我去了解了它的优点有以下几个：使用线程可以把占据长时间的程序中的任务放到后台去处理。
用户界面可以更加吸引人，比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。
程序的运行速度可能加快。
在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
and so on

掌握threading几个重点命令

threading.active_count() #获取已激活的线程数
threading.enumerate() #查看所有线程信息
threading.Thread(target=thread_job, name=‘T1’) #这里的target是指线程函数，等于后面可以为一个定义好的函数def。name是线程名字，还有其他参数arg,group
added_thread.start() #added_thread线程工作
added_thread.join() #join让added_thread线程执行完毕在执行其他的线程，起到一个控制流程顺序的作用

time模块在线程中的作用

import time
time.sleep(0.1) #任务间隔0.1s并且sleep让线程进入休眠状态，没有join当前线程无法执行

queue在多线程中的作用

from queue import Queue

def fun(l,q):
    for i in range (len(l)):
        l[i] = l[i]**2
    q.put(l)   #多线程调用的函数不是用return返回值
def multithreading():
    q =Queue()    #q中存放返回值，代替return的返回值
    threads = []
    data = [[1,2,3],[3,4,5],[7,7,7],[8,8,8]]
    # 在多线程函数中定义四个线程，启动线程，将每个线程添加到多线程的列表中

    for i in range(4):   #定义四个线程
        t = threading.Thread(target=job,args=(data[i],q)) 
    #Thread首字母要大写，被调用的job函数没有括号，只是一个索引，参数在后面
        t.start()#开始线程
        threads.append(t) #把每个线程append到线程列表中
    
    
    
    
    # 分别join四个线程到主线程
    for thread in threads:
        thread.join()
    
    # 定义一个空的列表results，将四个线运行后保存在队列中的结果返回给空列表results
    results = []
    for _ in range(4):
          results.append(q.get())#获取得到的返回值
    print(results)
if __name__ == '__main__':
    multithreading()

输出结果为[[1, 4, 9], [9, 16, 25], [49,49,49], [64,64,64]]

lock锁

#全局变量A的值每次加1，循环10次，并打印
def job1():  
    global A,lock  #lock锁
    lock.acquire() # 加锁
    for i in range(10):
        A+=1
        print('job1',A)
    lock.release()

    
#函数二：全局变量A的值每次加10，循环10次，并打印    
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()

lock的作用以及使用方法

lock在不同线程使用同一共享内存时，能够确保线程之间互不影响，使用lock的方法是
在每个线程执行运算修改共享内存之前，执行lock.acquire()将共享内存上锁
确保当前线程执行时，内存不会被其他线程访问，执行运算完毕后
使用lock.release()将锁打开，保证其他的线程可以使用该共享内存

lock和join的区别

join在上面例子的使用

import threading
def job1():
   global A
   for i in range(10):
       A+=1
       print('job1',A)
       
def job2():
   global A
   for i in range(10):
       A+=10
       print('job2',A)

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

join的结果

job1 1
job1 2
job1 3
job1 4
job1 5
job1 6
job1 7
job1 8
job1job2  19
job2 29
job2 39
job2 499
job1 50

job2 60
job2 70
job2 80
job2 90
job2 100
job2 110
done

lock的运行结果如下

job1 1
job1 2
job1 3
job1 4
job1 5
job1 6
job1 7
job1 8
job1 9
job1 10
job2 20
job2 30
job2 40
job2 50
job2 60
job2 70
job2 80
job2 90
job2 100
job2 110