c++等待指令能用于哪些场景

C++中的等待指令（例如 std::this_thread::sleep_for 或 std::this_thread::yield）主要用于让当前线程暂停执行一段时间或者主动让出CPU时间片，以便其他线程有机会运行。以下是一些常见的应用场景：

1. 延时执行：当你需要让你的程序暂停一段时间（例如几秒钟或几分钟）时，可以使用等待指令。

   #include <iostream>
   #include <thread>
   #include <chrono>
   
   int main() {
       std::cout << "Starting...\n";
       std::this_thread::sleep_for(std::chrono::seconds(3)); // 等待3秒
       std::cout << "Finished.\n";
       return 0;
   }
   

2. 限制线程执行速度：在某些情况下，你可能希望限制线程的执行速度，以便更好地控制系统的资源使用。等待指令可以帮助你实现这一点。

   #include <iostream>
   #include <thread>
   #include <chrono>
   
   void print_numbers(int start, int end) {
       for (int i = start; i <= end; ++i) {
           std::cout<< i << std::endl;
           std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 每打印一个数字后等待100毫秒
       }
   }
   
   int main() {
       std::thread t1(print_numbers, 1, 10);
       std::thread t2(print_numbers, 11, 20);
   
       t1.join();
       t2.join();
   
       return 0;
   }
   

3. 实现自旋锁（spinlock）：在多线程编程中，自旋锁是一种简单的同步机制。当一个线程尝试获取已被其他线程持有的锁时，自旋锁会让线程持续检查锁的状态，直到锁变为可用状态。等待指令可以用于实现这一过程。

   #include <iostream>
   #include <atomic>
   #include <thread>
   
   std::atomic<bool> lock = false;
   
   void spin_lock(int retries) {
       while (retries > 0) {
           if (!lock.exchange(true)) { // 尝试获取锁，如果成功则返回false，否则返回true（表示锁已被占用）
               return;
           }
           std::this_thread::yield(); // 等待一段时间后重试
           --retries;
       }
   }
   
   void unlock() {
       lock.store(false);
   }
   
   int main() {
       std::thread t1(spin_lock, 10);
       std::thread t2(unlock);
   
       t1.join();
       t2.join();
   
       return 0;
   }
   

4. 与事件循环结合使用：在某些事件驱动的程序中，你可能需要等待特定事件的发生。等待指令可以与事件循环结合使用，以便在事件发生时执行相应的操作。

   #include <iostream>
   #include <thread>
   #include <chrono>
   #include <condition_variable>
   #include <mutex>
   
   std::mutex mtx;
   std::condition_variable cv;
   bool ready = false;
   
   void worker() {
       std::unique_lock<std::mutex> lock(mtx);
       cv.wait(lock, [] { return ready; }); // 等待ready变为true
       std::cout << "Ready!\n";
   }
   
   int main() {
       std::thread t(worker);
   
       {
           std::lock_guard<std::mutex> lock(mtx);
           ready = true; // 设置ready为true，以便worker线程可以继续执行
       }
       cv.notify_one(); // 通知worker线程
   
       t.join();
   
       return 0;
   }
   

请注意，等待指令并不能保证线程会立即停止执行。它们只是让线程暂停一段时间或者主动让出CPU时间片。在实际应用中，你可能需要结合其他同步机制（如互斥锁、条件变量等）来实现更复杂的线程同步。