线程间通信

2020-12-23

在一个进程内的所有线程共享全局变量，能够不使用其他的方式的前提下完成多线程之间的数据共享。由于线程可以对全局变量任意修改，这就可能造成多线程之间对全局变量的混乱。使用互斥锁，可以防止多个线程同时读写某一块内存区域。

互斥锁有两种状态，锁定和非锁定。在某线程要修改共享数据时需要进行上锁，而在线程资源释放时需要解除锁定。将资源状态变为非锁定状态。互斥锁能够保证每次只有一个线程进行写入操作，从而保证了多线程数据的正确性。

1
2
3

mutex = threading.Lock() #创建锁
mutex.acquire([blocking]) #锁定
mutex.release() #释放锁

说明：

acquire([blocking]) :获取锁定，如果有必要，需要阻塞到锁定释放位置。如果提供blocking为False,无法获取锁时立即返回False,如果成功获取锁返货True

release() :释放锁。当锁处于为锁定状态，或者时其他线程中acquire()的锁，那么在本线程中使用release将会出现错误。

示例代码如下：

from threading import Thread,Lock
import time
n = 100
def task():
    global n
    mutex.acquire()     #加锁
    temp = n
    time.sleep(0.1)
    n = temp - 1
    print("购买成功 还剩 %d 张电影票"%n)
    mutex.release()       #释放锁
if __name__ == '__main__':
    mutex = Lock()
    t_l = []
    for i in range(10):
        t = Thread(target=task)
        t_l.append(t)
        t.start()
    for t in t_l:
        t.join()

除了使用互斥锁之外，还可以使用队列来进行线程间的通信，对于队列的接口，在进程间的通信已经讲过，这里不再多说，直接来看一下示例代码：

from queue import Queue
import random,threading,time
#生成者
class Producer(threading.Thread):
    #构造函数
    def __init__(self,name,queue):
        super(Producer,self).__init__(name=name)
        self.data = queue
    def run(self):
        for i in range(10):
            print("生成者 %s 将产品 %d 取出"%(self.getName(),i))
            self.data.put(i)
            time.sleep(random.random())
        print("生成完成")
#消费者
class Consumer(threading.Thread):
    def __init__(self,name,queue):
        super(Consumer,self).__init__(name=name)
        self.data = queue
    def run(self):
        for i in range(10):
            value = self.data.get(i)
            print("消费者者 %s 将产品 %d加入队列" % (self.getName(),value))
            time.sleep(random.random())
        print("消费完成")

if __name__ == '__main__':
    queue = Queue()
    producer = Producer("Producer",queue)
    consumer = Consumer("Consumer",queue)
    producer.start()
    consumer.start()
    producer.join()
    consumer.join()