python多进程与多线程的区别-Python3多进程与多线程区别及使用（2.线程）

threading模块

简述：

threading模块

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

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

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

thread类

run(): 用以表示线程活动的方法。

start():启动线程活动。

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

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

getName(): 返回线程名。

setName(): 设置线程名。

开启线程的两种方式：

一：

1 from threading importThread2

3

4 defsayhi(name):5 print("%s say hello" %name)6

7

8 if __name__ == "__main__":9 t = Thread(target=sayhi, args=("hh",))10 t.start()11 print("主线程")

二：

from threading importThreadimporttimeclassSayhi(Thread):def __init__(self,name):

super().__init__()

self.name=namedefrun(self):

time.sleep(2)print("%s say hello" %self.name)if __name__ == "__main__":

t= Sayhi("hh")

t.start()print("主线程")

线程同步：

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。

importthreadingimporttimeclassmyThread (threading.Thread):def __init__(self, threadID, name, counter):

threading.Thread.__init__(self)

self.threadID=threadID

self.name=name

self.counter=counterdefrun(self):print ("开启线程：" +self.name)#获取锁，用于线程同步

threadLock.acquire()

print_time(self.name, self.counter,3)#释放锁，开启下一个线程

threadLock.release()defprint_time(threadName, delay, counter):whilecounter:

time.sleep(delay)print ("%s: %s" %(threadName, time.ctime(time.time())))

counter-= 1threadLock=threading.Lock()

threads=[]#创建新线程

thread1 = myThread(1, "Thread-1", 1)

thread2= myThread(2, "Thread-2", 2)#开启新线程

thread1.start()

thread2.start()#添加线程到线程列表

threads.append(thread1)

threads.append(thread2)#等待所有线程完成

for t inthreads:

t.join()print ("退出主线程")

线程优先级队列（ Queue）

Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。

这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。

Queue 模块中的常用方法:

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() 实际上意味着等到队列为空，再执行别的操作

importqueueimportthreadingimporttime

exitFlag=0classmyThread (threading.Thread):def __init__(self, threadID, name, q):

threading.Thread.__init__(self)

self.threadID=threadID

self.name=name

self.q=qdefrun(self):print ("开启线程：" +self.name)

process_data(self.name, self.q)print ("退出线程：" +self.name)defprocess_data(threadName, q):while notexitFlag:

queueLock.acquire()if notworkQueue.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=[]

threadID= 1

#创建新线程

for tName inthreadList:

thread=myThread(threadID, tName, workQueue)

thread.start()

threads.append(thread)

threadID+= 1

#填充队列

queueLock.acquire()for word innameList:

workQueue.put(word)

queueLock.release()#等待队列清空

while notworkQueue.empty():pass

#通知线程是时候退出

exitFlag = 1

#等待所有线程完成

for t inthreads:

t.join()print ("退出主线程")