python 之多線程編程

今天，看了python 核心編程的第四章，多線程編程，記錄一下要點。

1、進程和線程

進程是一個執行中的程序，每個進程都有自己的地址空間、內存、數據棧以及其他用於跟蹤執行的輔助數據.。

線程，實在同一個進程下執行的，共享相同的上下文，一個進程中的各個線程與主線程共享一片數據空間，線程之間的信息共享和通信會更加容易。

2、使用多線程

python 中有thread 模塊和 threading 模塊

thread模塊的核心函數是thread.start_new_thread(),使用thread模塊的事例.

import thread
from time import ctime, sleep

loops = [4,2]
def loop(nloop, nsec, lock):
	print 'start loop', nloop, 'at:', ctime()
	sleep(nsec)
	print 'loop', nloop, 'done at:' , ctime()
	lock.release()
def main():
	print 'starting at:', ctime()
	locks = []
	nloops = range(len(loops))

	for i in nloops:
		lock = thread.allocate_lock()
		lock.acquire()
		locks.append(lock)
	for i in nloops:
		thread.start_new_thread(loop,(i, loops[i], locks[i]))
	for i in nloops:
		while locks[i].locked():
			pass
	print 'all Done at: ', ctime()
if __name__ == '__main__':
	main()

threading 模塊

threadIng模塊與thread模塊相比，它支持守護線程。守護線程的概念可以這樣理解，如果一個線程設置爲守護線程，就表示這個線程是不重要的，進程退出時不需要等待這個線程執行完成。

如果要將一個線程設置爲守護線程，需要在線程執行之前，設置 thread.daemon = True

使用Thread 類創建多線程事例，

import threading
from time import sleep, ctime

class MyThread(threading.Thread):
	"""docstring for MyThread"""
	def __init__(self, func, args, name=''):
		super(MyThread, self).__init__()
		self.name = name
		self.func = func
		self.args = args
	def getResult(self):
		return self.res
	def run(self):
		self.res = self.func(*self.args)
		
loops = [4,2]
def loop(nloop, nsec):
	print 'start loop', nloop, 'at: ', ctime()
	sleep(nsec)
	print 'loop done', nloop, 'at: ', ctime()
	return 'ws'

def main():
	print 'starting at: ', ctime()
	threads = []
	nloops = range(len(loops))

	for i in nloops:
		#t = threading.Thread(target = loop, args = (i, loops[i]))
		t = MyThread(loop,(i,loops[i]),loop.__name__)
		threads.append(t)
	for i in nloops:
		threads[i].start()
		
	for i in nloops:
		threads[i].join()
		print threads[i].getResult()	
if __name__ == '__main__':
	main()

3、同步原語

使用同步的情況，在使用多線程時，有些特定的函數或者代碼塊不希望被多個線程同時執行。

#!/usr/bin/env python

from atexit import register
from random import randrange
from threading import Thread, Lock, currentThread
from time import sleep, ctime

class CleanOutputSet(set):
    def __str__(self):
        return ', '.join(x for x in self)

lock = Lock()
loops = (randrange(2, 5) for x in xrange(randrange(3, 7)))
remaining = CleanOutputSet()

def loop(nsec):
    myname = currentThread().name
    lock.acquire()
    remaining.add(myname)
    print '[%s] Started %s' % (ctime(), myname) #print '[{0}] Started {1}'.format(ctime(), myname)
    lock.release()
    sleep(nsec)
    lock.acquire()
    remaining.remove(myname)
    print '[%s] Completed %s (%d secs)' % ( #print '[{0}] Completed {1} ({2} secs)'.format(
        ctime(), myname, nsec)
    print '    (remaining: %s)' % (remaining or 'NONE') #print '    (remaining: {0})'.format(remaining or 'NONE')
    lock.release()

def _main():
    for pause in loops:
        Thread(target=loop, args=(pause,)).start()

@register
def _atexit():
    print 'all DONE at:', ctime()

if __name__ == '__main__':
    _main()

python支持的多種類型的同步原語，包括鎖/互斥、信號量

使用鎖時，調用lock.require()函數獲取鎖，調用lock.release()函數釋放鎖