python基础篇--threading(多线程)

谁践踏了优雅 2022-07-13 14:57 233阅读 0赞

threading（多线程）

在python里面提供两个标准库thread和threading提供对线程的支持，由于thread提供比较低级，原始的线程以及一个简单的锁。而threading提供了较为高级的线程，在此我们详细介绍一下threading

**方法：**

treading.currentThread():返回当前的线程变量

treading.enumerate():返回一个包含正在运行的线程的list。正在运行是指线程启动后，结束前，不包括启动前和终止后的线程

treading.activeCount():返回正在运行的线程数量，与len(threading.enumerate())有相同的结果

t.run():线程活动的方法。（线程具体做什么，在这里调用）

t.start():启动线程活动

t.join(\[time\]):等待至线程终止，这阻塞调用线程至线程的join()方法被调用终止-正常退出或者抛出未处理的异常，或是可选的超时发生。

isAlive(t):返回线程是否活动

getName(t):返回线程名

setName(t):设置线程名

**线程同步（锁Lock）：**

多个线程共同对摸个数据修改，可能出现不可以预料的结果，为了保证数据的正确性，需要对多个线程进行同步。可以通过threadLock = threading.Lock() 在线程中的run方法中。threadLock.acquire()锁定线程, threadLock.release()释放线程

**import** threading

**import** time

**def** **print\_time** (thread\_name , counter):

**while** counter:

time.sleep( 1 )

**print** "%s: %s" % (thread\_name , time.ctime(time.time()))

counter -= 1

threadTest2\_1  = threading.Thread( target =print\_time , args =( 'threadTest2\_1' , 3 )) \# target为调用的方法，args为参数以元组的形式传入

threadTest2\_2 = threading.Thread( target =print\_time , args =( 'threadTest2\_2' , 3 ))

threadTest2\_1 .start()

threadTest2\_2.start()

\# 输出结果：

\# threadTest2\_1: Wed Jan 11 16:19:08 2017

\# threadTest2\_2: Wed Jan 11 16:19:08 2017

\# threadTest2\_1: Wed Jan 11 16:19:09 2017

\# threadTest2\_2: Wed Jan 11 16:19:09 2017

\# threadTest2\_1: Wed Jan 11 16:19:10 2017

\# threadTest2\_2: Wed Jan 11 16:19:10 2017

显然直接调用的方法比较单一，下面我们采用类的方法：

**类调用：**

**import** threading

**import** time

**class** **Counter** (threading.Thread):

**def** \_\_init\_\_ ( self , thread\_lock , thread\_name):

*"""@summary: 初始化对象。*

*@param lock: 琐对象。*

*@param threadName: 线程名称。*

*"""*

super (Counter , self ). \_\_init\_\_ ( name =thread\_name) \# 注意：一定要显式的调用父类的初始化函数。

self .lock = thread\_lock

**def** **run** ( self ):

*"""@summary: 重写父类run方法，在线程启动后执行该方法内的代码。*

*"""*

self .lock.acquire() \# 获得线程锁 acquire()和release()必须成对出现

print\_time( self .name , 3 )

self .lock.release() \# 释放锁

**def** **print\_time** (thread\_name , counter):

**while** counter:

time.sleep( 1 )

**print** "%s: %s" % (thread\_name , time.ctime(time.time()))

counter -= 1

lock = threading.Lock()

threads = \[\]

**for** i **in** range ( 3 ):

threadTest = Counter(lock , "thread-" \+ str (i))

threadTest.start()

threads.append(threadTest)

**print** threading.activeCount() \# 当前线程活动数 4 3+1主线程

**for** t **in** threads: \# 等待所有线程完成

t.join()

**print** 'Exiting Main Thread'

\# 输出结果：

\# 4

\# thread-0: Wed Jan 11 16:23:28 2017

\# thread-0: Wed Jan 11 16:23:29 2017

\# thread-0: Wed Jan 11 16:23:30 2017

\# thread-1: Wed Jan 11 16:23:31 2017

\# thread-1: Wed Jan 11 16:23:32 2017

\# thread-1: Wed Jan 11 16:23:33 2017

\# thread-2: Wed Jan 11 16:23:34 2017

\# thread-2: Wed Jan 11 16:23:35 2017

\# thread-2: Wed Jan 11 16:23:36 2017

\# Exiting Main Thread

显然通过建类的方式可以在run方法里面调用多个函数。

对于是直接调用还是通过建类的方式调用，这个要看具体场景的复杂情况。

**线程队列：**

Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

Queue.qsize()：返回队列的大小

Queue.empty()：如果队列为空，返回True,反之False

Queue.full()：如果队列满了，返回True,反之False

Queue.full 与 maxsize 大小对应

Queue.get(\[block\[, timeout\]\])：获取队列，timeout等待时间

Queue.get\_nowait()： 相当Queue.get(False)

Queue.put(item) ：写入队列，timeout等待时间

Queue.put\_nowait(item) ：相当Queue.put(item, False)

Queue.task\_done() ：在完成一项工作之后，Queue.task\_done()函数向任务已经完成的队列发送一个信号

Queue.join() ：实际上意味着等到队列为空，再执行别的操作

**import** Queue

**import** threading

**import** time

exitFlag = 0

**class** **myThread** (threading.Thread):

**def** \_\_init\_\_ ( self , name , q):

threading.Thread. \_\_init\_\_ ( self )

self .name = name

self .q = q

**def** **run** ( self ):

**print** "Starting " \+ self .name

process\_data( self .name , self .q)

**print** "Exiting " \+ self .name

**def** **process\_data** (threadName , q):

**while not**  exitFlag:

queueLock.acquire()

**if not**  workQueue.empty():

data = q.get() \# 消费队列

queueLock.release()

**print** "%s processing %s" % (threadName , data)

**else** :

queueLock.release()

time.sleep( 1 )

threadList = \[ "Thread-1" , "Thread-2" , "Thread-3" \]

nameList = \[ "One" , "Two" , "Three" , "Four" , "Five" \]

queueLock = threading.Lock()

workQueue = Queue.Queue( 10 )

threads = \[\]

\# 创建新线程

**for** tName **in** threadList:

thread = myThread(tName , workQueue)

thread.start()

threads.append(thread)

\# 填充队列

queueLock.acquire()

**for** word **in** nameList:

workQueue.put(word) \# 写入队列

queueLock.release()

\# 等待队列清空

**while not** workQueue.empty():

**pass**

\# 通知线程是时候退出

exitFlag = 1

\# 等待所有线程完成

**for** t **in** threads:

t.join()

**print** "Exiting Main Thread"

**threading 缺点** **：** 如果多个线程共享一个变量（上Lock）时候，会把多线程并发变成并行，也就是说假如有一个线程阻塞的话，其他所有线程都会等待。

python基础篇--threading(多线程)

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Python多线程Thread

相关 Python基础知识——多线程threading和thread

相关 python基础--Python多线程的使用，Threading

相关 python多线程编程-基础篇

相关 Python多线程thread与threading实现

相关 python基础篇--threading(多线程)

相关 python多线程模块thread

相关 Python基础之线程（Thread）

相关 python3多线程threading、_thread、Queue

相关 Python threading Thread多线程的使用方法