B-2. 公共汽车问题-线程 实现公共汽车上司机、售票员和乘客之间的同步。 只有车停下后，售票员才能开门， 只有售票员开门后，乘客才能上、下车， 只有乘客上车后，售票员才能开关门， 只有售票员关好门后，司机才能开车。 假设初态时车已停稳，售票员没开门

这是一个经典的同步问题，可以使用线程的同步机制来实现。以下是可能的一种实现方式：

import threading

class Bus:
    def __init__(self):
        self.driver_lock = threading.Lock()    # 司机锁
        self.conductor_lock = threading.Lock()  # 售票员锁
        self.passenger_lock = threading.Lock()  # 乘客锁

        self.driver_lock.acquire()   # 初始状态下车已停稳，司机未开车，获取司机锁

    def driver_start(self):
        self.driver_lock.release()   # 司机开车，释放司机锁
        print('司机已开车')

    def conductor_open_door(self):
        self.conductor_lock.acquire()   # 售票员开门前必须等车停稳，获取售票员锁
        print('售票员已开门')

    def conductor_close_door(self):
        print('售票员已关门')
        self.conductor_lock.release()   # 售票员关门后，释放售票员锁

    def passenger_board(self):
        self.passenger_lock.acquire()   # 乘客上车前必须等售票员开门，获取乘客锁
        print('乘客已上车')

    def passenger_alight(self):
        print('乘客已下车')
        self.passenger_lock.release()   # 乘客下车后，释放乘客锁

上述代码实现了一个 Bus 类，包含了司机、售票员和乘客的行为。每个行为都需要获取对应的锁才能执行。具体的同步步骤如下：

1. 初始状态下，车已停稳，司机未开车，获取司机锁。
2. 司机开车，释放司机锁。
3. 售票员等待司机停车后才能开门，获取售票员锁。
4. 售票员开门后，等待乘客上车，不释放售票员锁。
5. 乘客上车前必须等待售票员开门，获取乘客锁。
6. 乘客上车后，售票员等待乘客下车后关门，不释放售票员锁。
7. 乘客下车后，释放乘客锁。
8. 售票员关门后，释放售票员锁。
9. 回到步骤3，重复上述过程。

可以使用多个线程来模拟司机、售票员和乘客的行为，具体代码如下：

bus = Bus()

def driver_thread():
    bus.driver_start()

def conductor_thread():
    bus.conductor_open_door()
    bus.passenger_board()
    bus.conductor_close_door()

def passenger_thread():
    bus.passenger_alight()

# 创建线程
driver = threading.Thread(target=driver_thread)
conductor = threading.Thread(target=conductor_thread)
passenger1 = threading.Thread(target=passenger_thread)
passenger2 = threading.Thread(target=passenger_thread)

# 启动线程
driver.start()
conductor.start()
passenger1.start()
passenger2.start()

# 等待线程结束
driver.join()
conductor.join()
passenger1.join()
passenger2.join()

上述代码创建了一个司机线程、一个售票员线程和两个乘客线程，分别执行对应的操作。通过 join() 方法等待线程结束，确保所有操作都已执行完毕。