互斥锁用来保证同一时间内只有一个线程在执行某段代码（临界区）。多线程编程最容易出问题的地方，就是临界区的界定和访问控制。下面是一个生产者，消费者的简单例子。生产者、消费者公用一个缓冲区，这里假定缓冲区只能存放一条消息。写一个代码

下面是一个使用互斥锁来解决生产者和消费者问题的简单例子，缓冲区只能存放一条消息：

import threading
import time

# 定义全局变量
buffer = None
lock = threading.Lock()

# 定义生产者线程函数
def producer():
    global buffer
    # 生产者线程不断往缓冲区中添加消息
    while True:
        # 模拟生产消息的耗时
        time.sleep(1)
        # 获取互斥锁，保证在添加消息的时候不会被其他线程打断
        lock.acquire()
        # 如果缓冲区中已经有消息，则等待消费者消费完
        while buffer is not None:
            lock.release()
            time.sleep(1)
            lock.acquire()
        # 生产者添加消息
        buffer = "Hello, World!"
        print("Producer produced %s" % buffer)
        # 释放互斥锁
        lock.release()

# 定义消费者线程函数
def consumer():
    global buffer
    # 消费者线程不断从缓冲区中取出消息
    while True:
        # 模拟消费消息的耗时
        time.sleep(1)
        # 获取互斥锁，保证在取出消息的时候不会被其他线程打断
        lock.acquire()
        # 如果缓冲区中没有消息，则等待生产者生产
        while buffer is None:
            lock.release()
            time.sleep(1)
            lock.acquire()
        # 消费者取出消息
        print("Consumer consumed %s" % buffer)
        buffer = None
        # 释放互斥锁
        lock.release()

# 创建生产者和消费者线程并启动
t1 = threading.Thread(target=producer)
t2 = threading.Thread(target=consumer)
t1.start()
t2.start()

在这个例子中，生产者不断往缓冲区中添加消息，消费者不断从缓冲区中取出消息。使用互斥锁来保护缓冲区，保证在添加和取出消息的时候不会被其他线程打断。同时，当缓冲区中已经有消息或者没有消息的时候，生产者和消费者都会等待相应的操作完成。