进程与线程(3)- python实现多线程

参考链接:https://www.jianshu.com/p/415976668b97?utm_campaign=maleskineutm_content=noteutm_medium=seo_notesutm_source=recommendationhttps://morvanzhou.github.io/tutorials/python-basic/threading/ ...

参考链接:

https://www.jianshu.com/p/415976668b97?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

https://morvanzhou.github.io/tutorials/python-basic/threading/ 

python多线程的实现

Python的标准库:threading模块块。

threading 模块提供的常用方法

  • 导入模块:

import threading

  • 获取已激活的线程数

threading.active_count()
# 2

  • 查看正在运行的所有线程信息

threading.enumerate()
# [<_MainThread(MainThread, started 140736011932608)>, <Thread(SockThread, started daemon 123145376751616)>]
输出的结果是一个<_MainThread(...)>带多个<Thread(...)>。

  • 查看现在正在运行的线程

threading.current_thread()
# <_MainThread(MainThread, started 140736011932608)>

 

1、Thread类

  • 构造方法:

添加线程 :Thread(group=None, target=None, name=None, args=(), kwargs={})

group: 线程组,目前还没有实现,库引用中提示必须是None;

target: 要执行的方法,代表这个线程要完成的任务,需自定义;

name: 线程名;

args/kwargs: 要传入方法的参数。

  • 实例方法:

  isAlive():返回线程是否在运行。正在运行指启动后、终止前。
  get/setName(name):获取/设置线程名。
  is/setDaemon(bool):获取/设置是后台线程(默认前台线程(False))。(在start之前设置)。

  • 如果是后台线程,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论成功与否,主线程和后台线程均停止;
  • 如果是前台线程,主线程执行过程中,前台线程也在进行,主线程执行完毕后,等待前台线程也执行完成后,程序停止

  start(): 启动线程。
  join([timeout]): 阻塞当前上下文环境的线程,直到调用此方法的线程终止或到达指定的timeout(可选参数)。

  • 例子:

 1 import threading
 2 
 3 def thread_job():
 4     print('This is a thread of %s' % threading.current_thread())
 5 
 6 def main():
 7     thread = threading.Thread(target=thread_job,) # 定义线程 
 8     thread.start() # 让线程开始工作
 9 
10 if __name__ == '__main__':
11   main()

 

2、join()

线程中调用该函数,实现该线程执行完后,才继续执行主线程或其他线程上的内容。Join可以控制多个线程的执行顺序。

 1 import threading
 2 import time
 3 
 4 def thread_job():
 5     print("T1 start\n")
 6     for i in range(10):
 7         time.sleep(0.1) # 任务间隔0.1s
 8     print("T1 finish\n")
 9 
10 added_thread = threading.Thread(target=thread_job, name='T1')
11 added_thread.start()
12 added_thread.join()
13 print("all done\n")

 

3、Queue

 1 #代码实现功能,将数据列表中的数据传入,使用四个线程处理,将结果保存在Queue中,线程执行完后,从Queue中获取存储的结果
 2 import threading
 3 import time
 4 from queue import Queue
 5 
 6 def job(l,q):
 7     for i in range (len(l)):
 8         l[i] = l[i]**2
 9     q.put(l)        #多线程调用的函数不能用return返回值
10 
11 def multithreading():
12     q =Queue()        #q中存放返回值,代替return的返回值
13     threads = []
14     data = [[1,2,3],[3,4,5],[4,4,4],[5,5,5]]
15     for i in range(4):     #定义四个线程
16         t = threading.Thread(target=job,args=(data[i],q)) #Thread首字母要大写,被调用的job函数没有括号,只是一个索引,参数在后面
17         t.start()#开始线程
18         threads.append(t) #把每个线程append到线程列表中
19     for thread in threads:
20         thread.join()    #分别join四个线程到主线程
21     results = []
22     for _ in range(4):
23         results.append(q.get())    #q.get()按顺序从q中拿出一个值
24     print(results)
25 
26 if __name___=='__main__':
27     multithreading() 

 

4、线程锁Lock

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

 1 import threading
 2 
 3 def job1():
 4     global A,lock
 5     lock.acquire()
 6     for i in range(10):
 7         A+=1
 8     print('job1',A)
 9     lock.release()
10 
11 def job2():
12     global A,lock
13     lock.acquire()
14     for i in range(10):
15         A+=10
16     print('job2',A)
17     lock.release()
18 
19 if __name__== '__main__':
20     lock=threading.Lock()
21     A=0
22     t1=threading.Thread(target=job1)
23     t2=threading.Thread(target=job2)
24     t1.start()
25     t2.start()
26     t1.join()
27     t2.join()

 

本文标题为:进程与线程(3)- python实现多线程

基础教程推荐