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

这是一个经典的线程同步问题，可以使用互斥锁和条件变量来实现。下面是一个可能的 C++ 代码实现：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx; // 互斥锁
std::condition_variable cv_door, cv_passenger, cv_driver; // 条件变量

bool driver_ready = false; // 司机是否准备就绪
bool ticket_collector_ready = false; // 售票员是否准备就绪
bool door_open = false; // 车门是否打开

void driver() {
    std::unique_lock<std::mutex> lock(mtx);
    driver_ready = true;
    std::cout << "Driver is ready.\n";
    cv_driver.notify_all(); // 唤醒等待司机准备就绪的线程

    while (true) {
        // 等待售票员开门
        cv_door.wait(lock, []{ return ticket_collector_ready && !door_open; });
        door_open = true;
        std::cout << "Door is open.\n";
        cv_passenger.notify_all(); // 唤醒等待上下车的乘客线程

        // 等待所有乘客上下车
        cv_door.wait(lock, []{ return !ticket_collector_ready && door_open; });
        door_open = false;
        std::cout << "Door is closed.\n";
        cv_passenger.notify_all(); // 唤醒等待开关门的乘客线程

        // 检查是否还有乘客需要上下车，如果没有就可以开车了
        if (!cv_passenger.wait_for(lock, std::chrono::seconds(1), []{ return ticket_collector_ready && !door_open; })) {
            std::cout << "All passengers have boarded. Driver is starting the bus.\n";
            driver_ready = false;
            cv_driver.notify_one(); // 唤醒等待司机的线程
            break;
        }
    }
}

void ticket_collector() {
    std::unique_lock<std::mutex> lock(mtx);
    ticket_collector_ready = true;
    std::cout << "Ticket collector is ready.\n";
    cv_door.notify_one(); // 唤醒等待开门的线程

    while (true) {
        // 等待乘客上下车
        cv_passenger.wait(lock, []{ return door_open; });
        ticket_collector_ready = false;
        std::cout << "Ticket collector is collecting tickets.\n";
        cv_door.notify_one(); // 关门后唤醒等待开关门的乘客线程

        // 等待乘客开关门
        cv_passenger.wait(lock, []{ return door_open; });
        ticket_collector_ready = true;
        std::cout << "Ticket collector is checking tickets.\n";
        cv_door.notify_one(); // 关门后唤醒等待开关门的乘客线程

        // 等待司机准备就绪
        cv_driver.wait(lock, []{ return driver_ready; });
    }
}

void passenger(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    std::cout << "Passenger " << id << " is waiting at the bus stop.\n";

    // 等待车门开放
    cv_passenger.wait(lock, []{ return door_open; });
    std::cout << "Passenger " << id << " is boarding the bus.\n";
    cv_passenger.notify_one(); // 通知其他等待开关门的乘客线程

    // 等待车门开放
    cv_passenger.wait(lock, []{ return door_open; });
    std::cout << "Passenger " << id << " is getting off the bus.\n";
    cv_passenger.notify_one(); // 通知其他等待开关门的乘客线程
}

int main() {
    std::thread t_driver(driver);
    std::thread t_ticket_collector(ticket_collector);
    std::thread t_passenger1(passenger, 1);
    std::thread t_passenger2(passenger, 2);
    std::thread t_passenger3(passenger, 3);

    t_driver.join();
    t_ticket_collector.join();
    t_passenger1.join();
    t_passenger2.join();
    t_passenger3.join();

    return 0;
}

在这个实现中，司机、售票员和乘客分别是三个线程。司机和售票员使用 `cv_driver` 和 `cv_door` 条件变量来同步，乘客使用 `cv_passenger` 条件变量来同步。车门状态由 `door_open` 变量来记录。每个线程在执行前都需要先获取互斥锁，以便能够安全地修改共享变量。

在主函数中，创建了一个司机线程、一个售票员线程和三个乘客线程。司机和售票员分别在 `driver()` 和 `ticket_collector()` 函数中循环执行同步操作，直到所有乘客都上下车完毕并且没有新的乘客需要上车时，司机才会停止循环，程序结束。乘客线程在 `passenger()` 函数中等待车门开放，上下车后通知其他乘客线程，然后等待车门开关后重新等待车门开放。

需要注意的是，这只是一个可能的解决方案，可能存在死锁和竞态条件等问题，需要根据实际情况进行调整和改进。