Python线程间的同步与互斥

最简单来说，假如有3个线程同时访问一个全局变量，那么很可能会操作互斥错误的情况，代码如下：

#!/usr/bin/python#encoding=utf-8import timeimport threadingindex = 0def printIndex():    global index    global lock    while index < 100:        print index,        index += 1        time.sleep(1)t1 = threading.Thread(target = printIndex, args=())t1.setDaemon(True)t1.start()t2 = threading.Thread(target = printIndex, args=())t2.setDaemon(True)t2.start()t3 = threading.Thread(target = printIndex, args=())t3.setDaemon(True)t3.start()time.sleep(10)

在没有互斥的情况下3个线程同时访问一个全局变量，最后结果如下：

由此可见，输出的完全是乱码，因为这个地方除了全局变量是临界资源外控制台也是一个临界资源。所以需要互斥操作。将程序改为：

#!/usr/bin/python#encoding=utf-8import timeimport threadingindex = 0lock = threading.RLock()def printIndex():    global index    global lock    while index < 100:        lock.acquire()        print(index),        index += 1        lock.release()        time.sleep(1)t1 = threading.Thread(target = printIndex, args=())t1.setDaemon(True)t1.start()t2 = threading.Thread(target = printIndex, args=())t2.setDaemon(True)t2.start()t3 = threading.Thread(target = printIndex, args=())t3.setDaemon(True)t3.start()time.sleep(100)

最后输出结果：

由此可见，输出时完全按顺序的。在代码中先用RLock()创建一个锁，当需要访问临界资源时进行加锁lock.require(),等退出时再释放锁lock.release()。

对于临界资源来说，用锁可以很方便实现互斥，而如果要实现同步，则需要用event。

假如程序中需要进行复杂的计算，现在将这计算在另一线程中运行，但是主程序怎么才能知道计算完成了呢？实例代码如下：

import timeimport threadingdef getSum(n, sum):    for i in range(0, n + 1):        sum[0] += i        time.sleep(0.1)     def main():    sum = [0]    t = threading.Thread(target = getSum, args=(100, sum,))    t.setDaemon(True)    t.start()    time.sleep(2)    print('sum = ', sum[0])    if __name__ == '__main__':    main()

现在需要求1 + 2 + 3 + ... + N 的和，计算放在单独线程中进行，但是我们不知道计算什么时候结束，只能假设2s，最后结果如下：

最后结果sum = 153，这显然是不正确的，即使是正确，也是巧合。这时就需要一个类似于信号的东西，让子进程结束后能够通过这个信号告诉主进程，event就可以配上用

场了。event和lock的用法差不多，下面是代码：

import timeimport threadingdef getSum(n, sum, event):    for i in range(0, n + 1):        sum[0] += i        time.sleep(0.1)    event .set()def main():    sum = [0]    event = threading.Event()    t = threading.Thread(target = getSum, args=(100, sum, event))    t.setDaemon(True)    t.start()    event.wait()    print('sum = ', sum[0])    if __name__ == '__main__':    main()

程序中用了event作为一个信号量，初始是没信号的，当子进程完成计算后将其设置为有信号，主进程wait返回，最后结果：

最后，写个生产者和消费者的模型吧：

import timeimport randomimport threadingdef producter(buffer, event):    while True:        event.wait()        event.clear()        if len(buffer) > 4:            print("the buffer is full! producter wait...")        else:            data = random.randint(1, 10)            print('the producter has put data: ', data)            buffer.append(data)        event.set()        time.sleep(0.8)    pass    def consumer(buffer, event):    while True:        event.wait()        event.clear()        if len(buffer) == 0:            print('he buffer is empty! consumer wait...')        else:            data = buffer[0]            del buffer[0]            print('the consumer has get data:', data)        event.set()        time.sleep(0.4)def main():    buffer = []    event = threading.Event()    event.set()    p = threading.Thread(target = producter, args=(buffer, event))    p.setDaemon(True)    p.start()    c = threading.Thread(target = consumer, args=(buffer, event))    c.setDaemon(True)    c.start()    if __name__ == '__main__':    main()    time.sleep(100)

这儿有个问题，这里是wait之后再手工clear的，那么这中间就有可能出现线程切换，有没有方法在wait返回后自动clear的呢？？