python 中的多线程

# encoding:utf-8  
import threading  
import time  
import random  
class sleepThread(threading.Thread):  
    def __init__(self):  
        threading.Thread.__init__(self)  
        print self.name+ ' is created!'

    def run(self):  
        randomTime = random.randint(1,9) # 生成 1~9的随机整数  
        time.sleep(randomTime)  
        print self.name+ ' slept for '+str(randomTime)+' seconds' 

if __name__ == '__main__':  
    threads = []  
    for i in range(5):  # 创建5个进程  
        th = sleepThread()  
        threads.append(th)  
        th.start()

    for t in threads:  
        t.join() 

    print 'all threads finished'

if __name__ == '__main__':

    for i in range(5):  # 创建5个进程  
        th = sleepThread()  
        th.start()  
    print 'all threads finished'  
```  
那么输出就像下面所示：

![][5]


那为什么不在`thread.start()`后执行join()呢？即主函数改成以下样子。  
```py

if __name__ == '__main__':  
    for i in range(5):  # 创建5个进程  
        th = sleepThread()  
        th.start()  
        th.join()  
    print 'all threads finished'  
```  
这样输出的结果就像下面一样：

![][6]

原因是线程join()后会阻塞后面线程的创建，导致线程无法并行，这样多线程就没有意义了。

### 将需要线程执行的函数传入线程构造函数中

上面是线程的一种创建方式，实现上面相同功能的另外一种创建方式如下：  
```py  
def sleepThread(threadName):  
    randomTime = random.randint(1,9) # 生成 1~9的随机整数  
    time.sleep(randomTime)  
    print threadName+ ' slept for '+str(randomTime)+' seconds' 

if __name__ == '__main__':  
    threads = []  
    for i in range(5):  
        th = threading.Thread(target=sleepThread,args=('Thread-'+str(i),))  
        threads.append(th)  
        th.start()

    for t in threads:  
        t.join()  
    print 'all threads finished'  
```  
利用了`threading.Thread`自身的构造函数，传入的target参数作为线程的`run`函数,args参数则为传入的run函数的参数。

输出结果如下所示：

![][7]

线程还有比较常用的方法比如说setdaemon(True),字面上的意思是设为守护线程，但是这个守护线程跟守护进程有很大的区别，**实际上setdaemon(True)的作用是保证主线程（就是任何进程最开始的那个线程）退出时，派生出来的线程也必须退出。**详细例子见http://stackoverflow.com/questions/5127401/setdaemon-function-in-thread

## 线程锁  
因为多线程共享一个进程内的资源，所以**多个线程同时修改同一个变量时会发生冲突。这时候就需要线程锁**了。比如说下面这段代码;  
```py  
count = 10

def modifyThread(num):  
    global count  
    for i in range(1000):  
        count -= num  
        count += num

if __name__ == '__main__':  
    threads = []  
    print 'before modifying, count=%s '%count  
    for i in range(5):  
        th = threading.Thread(target=modifyThread,args=(i,))  
        threads.append(th)  
        th.start()

    for t in threads:  
        t.join()

    print 'after modifying, count=%s '%count

```  
执行的的时候每次输出结果都不一样，例如下图：

![][8]

这是因为count是被多个线程同时修改了，解决方法就是利用线程锁`threading.Lock()`,每次需要修改count时先获取线程锁，修改完再释放。实例代码如下所示：  
```py  
count = 10

def modifyThread(num):  
    global count  
    threadLock.acquire()  
    try:  
        for i in range(1000):  
            count -= num  
            count += num  
    finally:  
        threadLock.release()


if __name__ == '__main__':  
    threads = []  
    threadLock = threading.Lock()  
    print 'before modifying, count=%s '%count  
    for i in range(5):  
        th = threading.Thread(target=modifyThread,args=(i,))  
        threads.append(th)  
        th.start()

    for t in threads:  
        t.join()

    print 'after modifying, count=%s '%count  
```  
当多个线程同时执行threadLock.acquire()时，只有一个线程能成功地获取锁，然后继续执行代码，其他线程就继续等待直到获得锁为止。

在其中一个线程获取了线程锁（threadLock.acquire()）后，其他线程便无法修改count，但是修改完后一定要记得释放线程锁（threadLock.release()），否则其他线程会一直处于blocked的状态，上面采用了`try-finally `保证锁一定被释放。除了`try-finally `,还可通过 `with` 语句实现锁的自动获取和释放, 也就是说上面的 `modifyThread` 函数可以写成下面的形式

```py  
def modifyThread(num):  
    global count  
    with threadLock:  
        for i in range(1000):  
            count -= num  
            count += num