如何在C++中休眠或暂停几秒钟_C++程序延时与休眠实现

#include <iostream>
#include <thread> // for std::this_thread::sleep_for
#include <chrono> // for std::chrono::seconds, milliseconds, etc.

int main() {
    std::cout << "程序开始运行..." << std::endl;

    // 休眠2秒
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "休眠2秒后继续执行。" << std::endl;

    // 休眠500毫秒
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    std::cout << "休眠500毫秒后继续执行。" << std::endl;

    // 休眠100微秒（注意：实际精度受操作系统调度影响）
    std::this_thread::sleep_for(std::chrono::microseconds(100));
    std::cout << "休眠100微秒后继续执行。" << std::endl;

    std::cout << "程序结束。" << std::endl;
    return 0;
}

#include <iostream>
#include <windows.h> // for Sleep

int main() {
    std::cout << "程序开始运行 (Windows)..." << std::endl;

    // 休眠3000毫秒 (3秒)
    Sleep(3000);
    std::cout << "休眠3秒后继续执行。" << std::endl;

    std::cout << "程序结束 (Windows)。" << std::endl;
    return 0;
}

#include <iostream>
#include <unistd.h> // for sleep and usleep (on POSIX systems)

int main() {
    std::cout << "程序开始运行 (POSIX)..." << std::endl;

    // 休眠1秒
    sleep(1);
    std::cout << "休眠1秒后继续执行。" << std::endl;

    // 休眠500000微秒 (0.5秒)
    // 注意：usleep可能已废弃，但仍可在许多系统上使用
    usleep(500000);
    std::cout << "休眠0.5秒后继续执行。" << std::endl;

    std::cout << "程序结束 (POSIX)。" << std::endl;
    return 0;
}

#include <iostream>
#include <thread>
#include <chrono>

int main() {
    auto start_time = std::chrono::high_resolution_clock::now();
    std::cout << "尝试休眠100毫秒..." << std::endl;

    std::this_thread::sleep_for(std::chrono::milliseconds(100));

    auto end_time = std::chrono::high_resolution_clock::now();
    auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();

    std::cout << "实际休眠时间: " << elapsed_ms << " 毫秒。" << std::endl;
    // 很多时候，你会发现 elapsed_ms 会略大于 100
    return 0;
}

#include <iostream>
#include <chrono>
#include <thread> // 模拟其他工作

int main() {
    auto last_action_time = std::chrono::steady_clock::now();
    const auto interval = std::chrono::seconds(2); // 每2秒执行一次操作

    std::cout << "程序开始运行，将每2秒执行一次操作..." << std::endl;

    for (int i = 0; i < 10; ++i) { // 模拟运行10次
        auto current_time = std::chrono::steady_clock::now();
        if (current_time - last_action_time >= interval) {
            std::cout << "时间到！执行周期性操作 " << i + 1 << "。" << std::endl;
            last_action_time = current_time; // 更新上次操作时间
        }

        // 模拟当前线程在等待期间执行的其他轻量级工作
        // 比如处理用户输入、渲染帧、检查网络状态等
        std::cout << "  执行其他工作..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟小段的忙碌
    }

    std::cout << "程序结束。" << std::endl;
    return 0;
}

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

std::mutex mtx;
std::condition_variable cv;
bool data_ready = false;

void consumer_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    std::cout << "消费者线程：等待数据或超时..." << std::endl;

    // 等待数据，最长等待3秒
    if (cv.wait_for(lock, std::chrono::seconds(3), []{ return data_ready; })) {
        std::cout << "消费者线程：收到数据！" << std::endl;
    } else {
        std::cout << "消费者线程：等待超时，数据未就绪。" << std::endl;
    }
}

void producer_thread() {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟生产数据需要1秒
    {
        std::lock_guard<std::mutex> lock(mtx);
        data_ready = true;
        std::cout << "生产者线程：数据已准备好。" << std::endl;
    }
    cv.notify_one(); // 通知消费者数据已就绪
}

int main() {
    std::thread producer(producer_thread);
    std::thread consumer(consumer_thread);

    producer.join();
    consumer.join();

    std::cout << "主线程结束。" << std::endl;
    return 0;
}

// 概念性代码，非完整可运行
#include <boost/asio.hpp>
#include <iostream>
#include <functional> // for std::bind

void handle_timeout(const boost::system::error_code& error) {
    if (!error) {
        std::cout << "定时器触发！" << std::endl;
    } else {
        std::cerr << "定时器错误: " << error.message() << std::endl;
    }
}

int main() {
    boost::asio::io_context io_context;
    boost::asio::steady_timer timer(io_context, boost::asio::chrono::seconds(3));

    std::cout << "设置一个3秒的定时器..." << std::endl;
    timer.async_wait(handle_timeout); // 异步等待

    // 在等待定时器期间，io_context可以处理其他事件
    std::cout << "主线程正在执行其他任务..." << std::endl;
    io_context.run(); // 运行事件循环，直到所有异步任务完成

    std::cout << "主线程结束。" << std::endl;
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

std::mutex common_mutex;
int shared_resource = 0;

void bad_thread_func() {
    std::cout << "线程 " << std::this_thread::get_id() << " 尝试获取锁..." << std::endl;
    std::lock_guard<std::mutex> lock(common_mutex); // 获取锁
    std::cout << "线程 " << std::this_thread::get_id() << " 已获取锁，并开始休眠..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3)); // 在持有锁的情况下休眠
    shared_resource++;
    std::cout << "线程 " << std::this_thread::get_id() << " 休眠结束，释放锁。资源值: " << shared_resource << std::endl;
}

void good_thread_func() {
    std::cout << "线程 " << std::this_thread::get_id() << " 准备工作..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 先做一些不依赖锁的工作

    std::cout << "线程 " << std::this_thread::get_id() << " 尝试获取锁..." << std::endl;
    std::lock_guard<std::mutex> lock(common_mutex); // 获取锁
    shared_resource++;
    std::cout << "线程 " << std::this_thread::get_id() << " 已获取锁，修改资源，并释放锁。资源值: " << shared_resource << std::endl;
}

int main() {
    std::thread t1(bad_thread_func);
    std::thread t2(bad_thread_func); // 另一个线程会因为t1持有锁而长时间阻塞

    t1.join();
    t2.join(); // t2会等到t1休眠结束并释放锁后才能继续

    std::cout << "---------------------------------" << std::endl;

    shared_resource = 0; // 重置资源
    std::thread t3(good_thread_func);
    std::thread t4(good_thread_func); // 这两个线程会更高效地竞争锁

    t3.join();
    t4.join();

    return 0;
}