python——线程相关
使用python的threading中的Thread
下面是两种基本的实现线程的方式:
第一种方式————
#coding=utf-8 """ thread的第一种声明及调用方式 """ from threading import Thread import time def func(): while True: print time.ctime() time.sleep(1) def func1(): while True: print "func1", time.ctime() time.sleep(2) #将要执行的方法作为参数传给Thread的构造方法 t = Thread(target=func) t.start() t1 = Thread(target=func1) t1.start()
第二种方式————
#coding=utf-8 """ thread的第二种声明及调用方法 """ import time from threading import Thread from time import sleep #从Thread继承,并重写run() class myThread(Thread): def __init__(self, threadname): Thread.__init__(self, name=threadname) def run(self): while True: print self.getName() + " " + time.ctime() time.sleep(1) t = myThread("thread_1") t.start() t1 = myThread("thread_2") t1.start()
接下来是:join和setDaemon的方法调用及具体区别:
join的方法调用:
#coding=utf-8 """ join方法的含义是:存在A主线程,B子线程,在A主线程中生成了一个子线程B, 如果子线程B调用了join方法,则主线程需要等待子线程操作结束,才能够继续往下执行,主线程会被阻塞 """ import time from threading import Thread class myThread(Thread): def __init__(self, threadname): Thread.__init__(self, name = threadname) def run(self): time.sleep(10) print self.getName() + " " + time.ctime() def mainfunc(): for i in range(5): print i if __name__ == "__main__": t = myThread("childthread") t.start() #增加join方法的调用,则程序运行时的表现是:先子线程(会先sleep 10s,之后打印子线程的内容),再运行主线程中的打印从0到4的逻辑 #不增加join方法的调用,则程序运行时的表现是:会先走主线程的打印从0到4的逻辑,之后子线程(sleep 10s,再打印子线程中的内容),但其实这里就是没有等待子线程 # t.join() mainfunc()
setDaemon方法的调用:
#coding=utf-8 """ daemon方法的含义是:存在主线程A,和子线程B,子线程B是从主线程A中生成的 如果设置子线程B为daemon即守护进程,则主线程A不存在的话,子线程B就退出 如果没有设置子线程B为daemon,则主线程A结束运行退出之后,子线程B也不退出 """ import time from threading import Thread class myThread(Thread): def __init__(self, threadname): Thread.__init__(self, name=threadname) def run(self): time.sleep(10) print self.getName() + " " + time.ctime() def mainfunc(): for i in range(5): print i if __name__ == "__main__": t = myThread("zixiancheng") #不设置子线程为守护进程,则主线程退出,子线程继续运行 #设置子线程为守护进程,则主线程退出,子线程直接退出 #并且,需要在start之前调用setDaemon # t.setDaemon(True) t.start() mainfunc()
接下来是线程同步相关的内容:
首先是没有线程同步机制的情况下,多个线程同时操作一个公共数据:
代码如下:
#coding=utf-8 """ @function: test Thread的Lock @author: LiXia @date: 2017-0303 """ """ 所有的锁都是为了在线程之间进行通信 例如对一个公共变量进行操作,此例子为没有使用线程同步机制对公共变量进行操作 """ from threading import Thread import time data = 0 class myThread(Thread): def __init__(self): Thread.__init__(self) def run(self): global data time.sleep(1) data += 1 print self.getName() + " data: " + str(data) if __name__ == "__main__": for i in range(5): t = myThread() t.start()
运行结果见下方:
为了能够对公共操作的数据,在特定逻辑内保持一致,需要保证在该逻辑内,只有单个线程可以操作,其他线程需要等待该线程处理结束才可以。
所以下面是关于python线程同步机制提供的指令:
1、Lock:
但是将以上代码中增加上lock处理,注意一定要增加在对公共数据的逻辑判断和处理的前面和后面,所以这里必须添加到while判断之前,释放锁需要在输出操作结束之后添加
即:
#coding=utf-8 """ 所有的锁都是为了在线程之间进行通信 例如对一个公共变量进行操作 """ from threading import Thread import threading import time data = 0 lock = threading.Lock() class myThread(Thread): def __init__(self): Thread.__init__(self) def run(self): global data if lock.acquire(): time.sleep(1) data += 1 print self.getName() + " data: " + str(data) lock.release() if __name__ == "__main__": for i in range(5): t = myThread() t.start()
运行结果见下方:
2、RLock
代码如下:
#coding=utf-8 """ 通过RLock(可重入锁)进行线程间的安全通信,RLock为可重入锁,即线程在拥有RLock之后可以继续acquire(),只要保证acquire()次数与 release()次数一致即可; 继续对公共变量进行操作 """ from threading import Thread import threading import time rlock = threading.RLock() data = 0 class myThread(Thread): def __init__(self): Thread.__init__(self) def run(self): global data if rlock.acquire(): time.sleep(1) data += 1 print self.getName() + " data:" + str(data) if rlock.acquire(): time.sleep(1) data -= 1 print self.getName() + " data:" + str(data) rlock.release() rlock.release() if __name__ == "__main__": for i in range(5): t = myThread() t.start()
运行结果:
3、Condition
Condition就是条件变量,condition通常与一个锁关联。
acquire([timeout])/release(): 调用关联的锁的相应方法。
wait([timeout]): 调用这个方法将使线程进入Condition的等待池等待通知,并释放锁。使用前线程必须已获得锁定,否则将抛出异常。
notify(): 调用这个方法将从等待池挑选一个线程并通知,收到通知的线程将自动调用acquire()尝试获得锁定(进入锁定池);其他线程仍然在等待池中。调用这个方法不会释放锁定。使用前线程必须已获得锁定,否则将抛出异常。
notifyAll(): 调用这个方法将通知等待池中所有的线程,这些线程都将进入锁定池尝试获得锁定。调用这个方法不会释放锁定。使用前线程必须已获得锁定,否则将抛出异常。
#coding=utf-8 """ 以最经典的生产者和消费者的问题为例,两者需要针对一个公共的数据区域做操作,并且两端需要进行通信 生产者在生产之前,需要先占领地盘,然后开始生产,生产结束通知消费者来取; 消费者在消费的时候,也需要先占领地盘,然后开始消费,消费结束通知生产者继续生产; 当然还有多个生产者和消费者的情况,会更加复杂,可以用python的Queue来实现 """ from threading import Thread import threading import time import random product = [] con = threading.Condition() #得到一个Condition的对象 #生产者线程 class producerThread(Thread): def __init__(self, threadname): Thread.__init__(self, name=threadname) def run(self): global product if con.acquire(): while True: r = random.randint(0, 20) product.append(r) print "product len and product: ", self.getName(), product con.notify() con.wait() # time.sleep(2) #消费者线程 class consumerThread(Thread): def __init__(self, threadname): Thread.__init__(self, name=threadname) def run(self): global product if con.acquire(): while True: if product != []: product.pop() print "consumer len and product: ", self.getName(), product con.notify() con.wait() time.sleep(2) if __name__ == "__main__": t1 = producerThread("producer") t2 = consumerThread("consumer") t1.start() t2.start()
运行结果如下:
4、对多个生产者消费者支持的很好的Queue
Queue是什么?Queue实现了多生产者-多消费者的队列形式,分别包含先入先出(默认)FIFO、后进先出LIFO、以及优先级队列PriorityQueue(优先级低的先出)
Queue模块的class及exception:
#coding=utf-8 """ Queue的类和异常 """ import Queue q = Queue.Queue(maxsize = 0) #FIFO的Queue,maxsize即Queue的size值,maxsize≤0表示无size限制 lq = Queue.LifoQueue(maxsize = 0) #LIFO的Queue,先进后出,maxsiz的含义同上 pq = Queue.PriorityQueue(maxsize = 0) #优先级Queue,优先级低的先出,maxsize的含义同上 Queue.Empty() #当Queue的对象为空时,使用非阻塞get时会抛出异常 Queue.Full() #当Queue的对象已满时,使用非阻塞put时会抛出异常
Queue的对象:
Queue(Queue、LifoQueue、PriorityQueue)的对象提供的公共方法如下:
#coding=utf-8 """ Queue(Queue、LifoQueue、PriorityQueue)的对象的公共方法 """ import Queue q = Queue.Queue() q.qsize() #获取Queue的大小 q.empty() #是否为空,是则返回True,否则返回False q.full() #是否已满,是则返回True,否则返回False q.put(item[, block[, timeout]]) #put元素到Queue中,可选参数block默认值为True,timeout默认值为None,即为阻塞方法, #接上,若timeout为正值,则代表会阻塞timeout的时长之后引发一个full的异常(如果已满) q.put_nowait(item) #相当于q.put(item, False) q.get([block[, timeout]]) #get元素到Queue中,可选参数block默认值为True,timeout默认值为None,即为阻塞方法, #接上,若timeout为正数,则代表会则色timeouu的时长之后会引发一个empty的异常(如果为空) q.get_nowait() #相当于q.get(False) q.task_done() #用在Queue的消费者模式下,即用在Queue.get()方法之后,通过Queue.task_done()告诉Queue当前任务完成 #如果当前join正在阻塞,则它将在所有item都被处理之后恢复 q.join() #会保持阻塞直到队列中的所有item都会处理 #接上,未完成的task数目会增加当一个item被add到Queue中,未完成的task数目会降低,每当消费者线程调用task_done来表示所有的 #接上,work都完成了,当未完成的数目降低到0时,join就自动取消阻塞了
Queue的主要用法是什么?
看一下Queue的源码实现,然后在另一篇博客中更新一下。
#coding=utf-8 """ 理解Queue的用法,理解Queue衍生出来的不同的class """ from Queue import Queue from threading import Thread import time import random q = Queue() class producerQueue(Thread): def __init__(self, queue): Thread.__init__(self) self.queue = queue def run(self): while True: r = random.randint(0, 99) self.queue.put(r) print self.getName() + "produce " + str(r) time.sleep(1) class consumerQueue(Thread): def __init__(self, queue): Thread.__init__(self) self.queue = queue def run(self): while True: r = self.queue.get() print self.getName() + "consume " + str(r) time.sleep(3) self.queue.task_done() if __name__ == "__main__": threads = [] for i in range(5): t = producerQueue(q) t.start() # threads.append(t) for i in range(3): t = consumerQueue(q) t.start() # threads.append(t) q.join()
之后得到的结果如下: