Python多线程：thread、threading、queue
一、名字解释
Python虚拟机：也叫解释器主循环，控制Python代码的执行。
多线程：类似单CPU系统中运行多个进程。 任意时刻，只能有一个线程在解释器中运行。
全局解释器锁（GIL）：保证同一个时刻只有一个线程在运行。
二、thread
#!/usr/bin/env python
#import thread
from time import sleep, ctime
def loop0():
print "start loop 0 at:", ctime()
sleep(4)
print "end loop 0 at:", ctime()
def loop1():
print "start loop 1 at:", ctime()
sleep(2)
print "end loop 1 at:",ctime()
def main():
print "starting at:", ctime()
loop0()
loop1()
#thread.start_new_thread(loop0,())
#thread.start_new_thread(loop1,())
#sleep(6)
print "ending at:", ctime();
if __name__ == "__main__":
main()
没有thread：共耗时4+2=6秒
有thread，无锁：并发执行，共耗时4秒，需要主线程中手动sleep
#!/usr/bin/env python
import thread
from time import sleep, ctime
secs = [4,2]
def loop(nloop, nsec, lock):
print "start loop ", nloop," at:", ctime()
sleep(nsec)
print "end loop ", nloop, " at:", ctime()
lock.release()
def main():
print "starting at:", ctime()
nsecs = range(len(secs))
locks = []
for i in nsecs:
lock = thread.allocate_lock()
lock.acquire()
locks.append(lock)
for i in nsecs:
thread.start_new_thread(loop, (i, secs[i], locks[i]))
for i in nsecs:
while locks[i].locked(): pass
print "ending at:", ctime();
if __name__ == "__main__":
main()
有thread，有锁：共耗时4秒，主线程无需等待
三、threading
3种创建线程方法
1. 创建一个Thread的实例，传给它一个函数
2. 创建一个Thread的实例，传给它一个可调用的类对象
3. 从Thread派生出一个子类，创建一个这个子类的实例
#!/usr/bin/env python
import threading
from time import sleep, ctime
secs = [4,2]
#class ThreadFunc(object):
# def __init__(self, func, args, name=''):
# self.name = name
# self.func = func
# self.args = args
#
# def __call__(self):
# apply(self.func, self.args)
def loop(nloop, nsec):
print "start loop ", nloop, " at:", ctime()
sleep(nsec)
print "end loop ", nloop," at:", ctime()
def main():
print "starting at:", ctime()
nsecs = range(len(secs))
threads = []
for i in nsecs:
#t = threading.Thread(target=ThreadFunc(loop, (i, secs[i]), loop.__name__))
t = threading.Thread(target=loop,args=(i,secs[i]))
threads.append(t)
for i in nsecs:
threads[i].start()
for i in nsecs:
threads[i].join()
print "ending at:", ctime();
if __name__ == "__main__":
main()
上述代码是2种创建线程方法：执行结果一样，都是耗时4秒，主线程无需等待
四、threading.Lock
import threading
g_lock = threading.Lock()
g_lock.acquire()
g_lock.release()
import threading
g_tickets = 100
g_lock = threading.Lock()
def loop1():
global g_tickets
global g_lock
while True:
g_lock.acquire()
if g_tickets > 0:
print("thread 1 sell tickets: %d" % (g_tickets))
g_tickets = g_tickets - 1
else:
g_lock.release()
break
g_lock.release()
def loop2():
global g_tickets
global g_lock
while True:
g_lock.acquire()
if g_tickets > 0:
print("thread 2 sell tickets: %d" % (g_tickets))
g_tickets = g_tickets - 1
else:
g_lock.release()
break
g_lock.release()
def main():
t1 = threading.Thread(target=loop1, args=());
t2 = threading.Thread(target=loop2, args=())
t1.start()
t2.start()
t1.join()
t2.join()
if __name__ == "__main__":
main()
五、尽量使用threading，避免使用thread
1. threading模块更为先进，对线程支持更完善，使用thread模块可能会与threading出现冲突。
2. thread模块同步原语少（只有一个），threading模块有很多。
3. thread，当主线程结束时，所有线程都被强制结束掉；threading模块能确保重要的子线程退出口进程再退出。
六、Queue
import Queue
queue = Queue.Queue(maxsize=10)
queue.put(num)
num = queue.get()
queue.qsize()
import threading
import Queue
import random
import time
queue = Queue.Queue(maxsize=10)
def loop1():
while True:
if queue.qsize() < 10:
num = random.randint(1, 100)
print("produce num: %d" % (num))
queue.put(num)
time.sleep(random.randint(1,3))
def loop2():
while True:
if queue.qsize > 0:
num = queue.get()
print("consumer num: %d" % (num))
time.sleep(random.randint(1,3))
def main():
t1 = threading.Thread(target=loop1, args=())
t2 = threading.Thread(target=loop2, args=())
t1.start()
t2.start()
t1.join()
t2.join()
if __name__ == "__main__":
main()