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()