powercfg /a

此系统上有以下睡眠状态:
    待机 (S0 低电量待机) 连接的网络
    休眠
    快速启动
此系统上没有以下睡眠状态:
    待机 (S1)
        系统固件不支持此待机状态。
    待机 (S2)
        系统固件不支持此待机状态。
    待机 (S3)
        当支持 S0 低电量待机时，禁用此待机状态。
    混合睡眠
        待机 (S3) 不可用。
        虚拟机监控程序不支持此待机状态。

此系统上有以下睡眠状态:
    待机 (S3)
    休眠
    混合睡眠
    快速启动
此系统上没有以下睡眠状态:
    待机 (S1)
        系统固件不支持此待机状态。
    待机 (S2)
        系统固件不支持此待机状态。
    待机 (S0 低电量待机)
        系统固件不支持此待机状态。

# 查看当前活动的电源计划
powercfg /getactivescheme
# 查看详细的电源设置
powercfg /query

控制面板 → 硬件和声音 → 电源选项 → 更改计划设置 → 更改高级电源设置

设置 → 系统 → 电源 → 屏幕和睡眠 → 根据需要设置

控制面板 → 电源选项 → 编辑计划设置
- "使计算机进入睡眠状态" → 从不
- "更改高级电源设置"
  → 睡眠 → 在此时间后睡眠 → 0（从不）
  → 睡眠 → 在此时间后休眠 → 0（从不）

# 以管理员身份运行
powercfg /h off

powercfg /h on

控制面板 → 电源选项 → 更改计划设置 → 更改高级电源设置 → 睡眠 → 允许混合睡眠 → 关闭

# 列出所有电源计划
powercfg /list
# 切换到高性能计划
powercfg /setactive 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c

EXECUTION_STATE SetThreadExecutionState(
  EXECUTION_STATE esFlags
);

// 阻止系统睡眠，允许显示器关闭
ES_CONTINUOUS | ES_SYSTEM_REQUIRED

// 阻止系统睡眠，同时保持显示器开启
ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED

// 恢复正常电源管理
ES_CONTINUOUS

using System;
using System.Runtime.InteropServices;
namespace PowerManagement
{
    /// <summary>系统睡眠状态控制类</summary>
    /// <remarks>
    /// <para>功能说明：</para>
    /// <para>通过调用 Windows Kernel32 API 控制系统电源管理行为，防止系统在程序运行期间自动进入睡眠或休眠状态。</para>
    /// <para>主要用于需要长时间持续运行的工业控制程序，避免因系统睡眠导致：</para>
    /// <list type="number">
    /// <item>PLC 通信连接断开</item>
    /// <item>设备控制序列中断</item>
    /// <item>实时监控数据丢失</item>
    /// <item>远程连接异常</item>
    /// </list>
    /// <para>技术说明：</para>
    /// <para>- 使用 SetThreadExecutionState API 设置线程执行状态标志</para>
    /// <para>- ES_CONTINUOUS 标志确保设置持续有效直到显式清除</para>
    /// <para>- ES_SYSTEM_REQUIRED 标志阻止系统自动进入睡眠模式</para>
    /// <para>- 程序异常退出时系统会自动清除标志，恢复正常电源管理</para>
    /// <para>应用场景：</para>
    /// <para>适用于台式机的传统 S3 睡眠模式和笔记本的现代 S0 待机模式，但不阻止用户手动触发的睡眠操作。</para>
    /// </remarks>
    public class SleepPreventer
    {
        /// <summary>阻止系统睡眠的工作模式</summary>
        public enum PreventMode
        {
            /// <summary>仅阻止系统睡眠，允许显示器关闭</summary>
            /// <remarks>适用场景：后台服务、无界面程序、允许显示器省电的情况</remarks>
            SystemOnly,
            /// <summary>阻止系统睡眠且保持显示器开启</summary>
            /// <remarks>适用场景：监控界面、远程桌面、需要持续显示的应用</remarks>
            SystemAndDisplay
        }
        /// <summary>设置线程执行状态的 Windows API</summary>
        /// <param name="esFlags">执行状态标志的组合值</param>
        /// <returns>返回之前的线程执行状态标志。</returns>
        /// <remarks>此 API 位于 kernel32.dll 中，用于通知系统当前线程正在执行关键操作，需要保持系统活动状态。</remarks>
        [DllImport("kernel32.dll")]
        static extern uint SetThreadExecutionState(uint esFlags);
        /// <summary>执行状态持续标志</summary>
        /// <remarks>
        /// 值：0x80000000
        /// <para>表示执行状态设置持续有效，直到下一次调用 SetThreadExecutionState 清除或程序终止。</para>
        /// <para>必须与 ES_SYSTEM_REQUIRED 或 ES_DISPLAY_REQUIRED 组合使用。</para>
        /// </remarks>
        const uint ES_CONTINUOUS = 0x80000000;
        /// <summary>系统必需标志</summary>
        /// <remarks>
        /// 值：0x00000001
        /// <para>通知系统当前线程需要系统保持活动状态。</para>
        /// <para>防止系统自动进入睡眠模式，但允许显示器关闭。</para>
        /// </remarks>
        const uint ES_SYSTEM_REQUIRED = 0x00000001;
        /// <summary>显示器必需标志</summary>
        /// <remarks>
        /// 值：0x00000002
        /// <para>通知系统当前线程需要显示器保持开启状态。</para>
        /// <para>防止显示器自动关闭，同时也阻止系统进入睡眠模式。</para>
        /// <para>注意：未在当前实现中使用，如需保持显示器开启可在 <see cref="PreventSleep"/> 方法中添加此标志。</para>
        /// </remarks>
        const uint ES_DISPLAY_REQUIRED = 0x00000002;
        /// <summary>阻止系统自动进入睡眠状态</summary>
        /// <param name="mode">防休眠模式</param>
        /// <returns>操作是否成功</returns>
        /// <remarks>
        /// <para>执行流程：</para>
        /// <list type="number">
        /// <item>调用 SetThreadExecutionState API 设置执行状态标志</item>
        /// <item>组合 ES_CONTINUOUS 和 ES_SYSTEM_REQUIRED 标志</item>
        /// <item>持续阻止系统自动睡眠，直到调用 <see cref="AllowSleep"/> 或程序终止</item>
        /// </list>
        /// <para>注意事项：</para>
        /// <para>- 仅阻止系统<b>自动</b>睡眠，不影响用户手动触发的睡眠操作</para>
        /// <para>- 显示器仍可能自动关闭（如需保持显示器开启，需添加 ES_DISPLAY_REQUIRED 标志）</para>
        /// <para>- 建议在程序主入口点或服务启动时调用</para>
        /// <para>- 程序崩溃或异常退出时，系统会自动清除此设置</para>
        /// <para>应用建议：</para>
        /// <para>适用于需要长时间连续运行的场景，如 PLC 通信监控、设备控制序列执行、数据采集等。</para>
        /// </remarks>
        /// <example>
        /// 在程序启动时调用：
        /// <code>
        /// public static void Main()
        /// {
        ///     SleepPreventer.PreventSleep();
        ///     // ... 程序主逻辑
        /// }
        /// </code>
        /// </example>
        public static bool PreventSleep(PreventMode mode = PreventMode.SystemOnly)
        {
            uint flags = ES_CONTINUOUS | ES_SYSTEM_REQUIRED;
            if (mode == PreventMode.SystemAndDisplay)
            {
                flags |= ES_DISPLAY_REQUIRED;
            }
            uint result = SetThreadExecutionState(flags);
            return result != 0;
        }
        /// <summary>恢复系统正常电源管理行为</summary>
        /// <remarks>
        /// <para>执行流程：</para>
        /// <list type="number">
        /// <item>调用 SetThreadExecutionState API 并仅传入 ES_CONTINUOUS 标志</item>
        /// <item>清除之前设置的 ES_SYSTEM_REQUIRED 标志</item>
        /// <item>系统恢复正常的自动睡眠行为</item>
        /// </list>
        /// <para>注意事项：</para>
        /// <para>- 建议在程序正常退出前调用，确保不影响系统的电源管理</para>
        /// <para>- 如果程序异常终止未调用此方法，系统会自动清除执行状态设置</para>
        /// <para>- 调用后系统将按照电源计划设置的时间自动进入睡眠</para>
        /// <para>应用建议：</para>
        /// <para>在程序关闭事件、服务停止事件或 Dispose 方法中调用此方法。</para>
        /// </remarks>
        /// <example>
        /// 在程序退出时调用：
        /// <code>
        /// protected override void OnClosed(EventArgs e)
        /// {
        ///     SleepPreventer.AllowSleep();
        ///     base.OnClosed(e);
        /// }
        /// </code>
        /// </example>
        public static void AllowSleep()
        {
            SetThreadExecutionState(ES_CONTINUOUS);
        }
    }
}

public partial class MainForm : Form
{
    public MainForm()
    {
        InitializeComponent();
        // 窗口加载时阻止休眠
        this.Load += (s, e) => SleepPreventer.PreventSleep();
        // 窗口关闭时恢复
        this.FormClosing += (s, e) => SleepPreventer.AllowSleep();
    }
}

public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);
        // 程序启动时阻止休眠
        SleepPreventer.PreventSleep();
    }
    protected override void OnExit(ExitEventArgs e)
    {
        // 程序退出时恢复
        SleepPreventer.AllowSleep();
        base.OnExit(e);
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 阻止休眠
        SleepPreventer.PreventSleep();
        Console.WriteLine("程序运行中，系统不会自动睡眠...");
        Console.WriteLine("按任意键退出");
        // 业务逻辑
        DoWork();
        Console.ReadKey();
        // 恢复正常
        SleepPreventer.AllowSleep();
    }
    static void DoWork()
    {
        // 长时间运行的任务
        while (true)
        {
            // PLC 通信、数据采集等
            Thread.Sleep(1000);
        }
    }
}

public partial class MyService : ServiceBase
{
    protected override void OnStart(string[] args)
    {
        // 服务启动时阻止休眠
        SleepPreventer.PreventSleep();
        // 启动业务逻辑
        StartWorkThread();
    }
    protected override void OnStop()
    {
        // 服务停止时恢复
        SleepPreventer.AllowSleep();
        // 停止业务逻辑
        StopWorkThread();
    }
}

// SleepPreventer.h
#ifndef SLEEP_PREVENTER_H
#define SLEEP_PREVENTER_H
#include <windows.h>
/**
 * @brief 系统睡眠状态控制类
 * 
 * 通过调用 Windows API 控制系统电源管理行为，防止系统在程序运行期间
 * 自动进入睡眠或休眠状态。
 * 
 * 主要用于需要长时间持续运行的工业控制程序，避免因系统睡眠导致：
 * - PLC 通信连接断开
 * - 设备控制序列中断
 * - 实时监控数据丢失
 * - 远程连接异常
 * 
 * @note 适用于 Windows XP SP1 及以上版本
 */
class SleepPreventer
{
public:
    /**
     * @brief 阻止系统自动进入睡眠状态
     * 
     * 执行流程：
     * 1. 调用 SetThreadExecutionState API 设置执行状态标志
     * 2. 组合 ES_CONTINUOUS 和 ES_SYSTEM_REQUIRED 标志
     * 3. 持续阻止系统自动睡眠，直到调用 AllowSleep() 或程序终止
     * 
     * @note 仅阻止系统自动睡眠，不影响用户手动触发的睡眠操作
     * @note 显示器仍可能自动关闭（如需保持显示器开启，调用 PreventSleepAndDisplay()）
     * @note 程序崩溃或异常退出时，系统会自动清除此设置
     * 
     * @return 成功返回 true，失败返回 false
     * 
     * @example
     * @code
     * int main()
     * {
     *     SleepPreventer::PreventSleep();
     *     
     *     // 你的业务逻辑
     *     DoWork();
     *     
     *     SleepPreventer::AllowSleep();
     *     return 0;
     * }
     * @endcode
     */
    static bool PreventSleep();
    /**
     * @brief 阻止系统睡眠并保持显示器开启
     * 
     * 相比 PreventSleep()，此方法同时保持显示器开启状态。
     * 适用于需要持续显示界面的应用程序（如监控系统、远程桌面等）。
     * 
     * @return 成功返回 true，失败返回 false
     * 
     * @example
     * @code
     * // 用于监控界面，保持屏幕常亮
     * SleepPreventer::PreventSleepAndDisplay();
     * @endcode
     */
    static bool PreventSleepAndDisplay();
    /**
     * @brief 恢复系统正常电源管理行为
     * 
     * 执行流程：
     * 1. 调用 SetThreadExecutionState API 并仅传入 ES_CONTINUOUS 标志
     * 2. 清除之前设置的 ES_SYSTEM_REQUIRED 标志
     * 3. 系统恢复正常的自动睡眠行为
     * 
     * @note 建议在程序正常退出前调用，确保不影响系统的电源管理
     * @note 如果程序异常终止未调用此方法，系统会自动清除执行状态设置
     * 
     * @return 成功返回 true，失败返回 false
     */
    static bool AllowSleep();
private:
    /// 执行状态持续标志（0x80000000）
    static const DWORD ES_CONTINUOUS = 0x80000000;
    /// 系统必需标志（0x00000001）- 阻止系统睡眠
    static const DWORD ES_SYSTEM_REQUIRED = 0x00000001;
    /// 显示器必需标志（0x00000002）- 保持显示器开启
    static const DWORD ES_DISPLAY_REQUIRED = 0x00000002;
};
#endif // SLEEP_PREVENTER_H

// SleepPreventer.cpp
#include "SleepPreventer.h"
bool SleepPreventer::PreventSleep()
{
    EXECUTION_STATE result = SetThreadExecutionState(
        ES_CONTINUOUS | ES_SYSTEM_REQUIRED
    );
    // SetThreadExecutionState 返回之前的状态，返回 0 表示失败
    return (result != 0);
}
bool SleepPreventer::PreventSleepAndDisplay()
{
    EXECUTION_STATE result = SetThreadExecutionState(
        ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED
    );
    return (result != 0);
}
bool SleepPreventer::AllowSleep()
{
    EXECUTION_STATE result = SetThreadExecutionState(ES_CONTINUOUS);
    return (result != 0);
}

// SleepPreventerRAII.h
#ifndef SLEEP_PREVENTER_RAII_H
#define SLEEP_PREVENTER_RAII_H
#include <windows.h>
/**
 * @brief RAII 风格的睡眠防护类
 * 
 * 使用 RAII（Resource Acquisition Is Initialization）模式自动管理
 * 睡眠防护的生命周期：
 * - 构造函数：自动阻止系统睡眠
 * - 析构函数：自动恢复正常电源管理
 * 
 * 这种方式确保即使发生异常，也能正确恢复系统电源设置。
 * 
 * @example
 * @code
 * void DoLongRunningTask()
 * {
 *     // 创建对象时自动阻止睡眠
 *     SleepPreventerRAII preventer;
 *     
 *     // 执行长时间任务
 *     ProcessData();
 *     CommunicateWithPLC();
 *     
 *     // 函数返回时自动析构，恢复电源管理
 * }
 * @endcode
 */
class SleepPreventerRAII
{
public:
    /**
     * @brief 防休眠模式枚举
     */
    enum class Mode
    {
        SystemOnly,         ///< 仅阻止系统睡眠，允许显示器关闭
        SystemAndDisplay    ///< 阻止系统睡眠且保持显示器开启
    };
    /**
     * @brief 构造函数 - 自动阻止系统睡眠
     * 
     * @param mode 防休眠模式
     */
    explicit SleepPreventerRAII(Mode mode = Mode::SystemOnly);
    /**
     * @brief 析构函数 - 自动恢复正常电源管理
     */
    ~SleepPreventerRAII();
    // 禁止拷贝和赋值
    SleepPreventerRAII(const SleepPreventerRAII&) = delete;
    SleepPreventerRAII& operator=(const SleepPreventerRAII&) = delete;
    /**
     * @brief 检查是否成功设置防休眠
     * 
     * @return 成功返回 true，失败返回 false
     */
    bool IsActive() const { return m_isActive; }
private:
    bool m_isActive;                    ///< 是否已成功激活防休眠
    EXECUTION_STATE m_previousState;    ///< 保存之前的执行状态
    static const DWORD ES_CONTINUOUS = 0x80000000;
    static const DWORD ES_SYSTEM_REQUIRED = 0x00000001;
    static const DWORD ES_DISPLAY_REQUIRED = 0x00000002;
};
#endif // SLEEP_PREVENTER_RAII_H

// SleepPreventerRAII.cpp
#include "SleepPreventerRAII.h"
SleepPreventerRAII::SleepPreventerRAII(Mode mode)
    : m_isActive(false)
    , m_previousState(0)
{
    DWORD flags = ES_CONTINUOUS | ES_SYSTEM_REQUIRED;
    if (mode == Mode::SystemAndDisplay)
    {
        flags |= ES_DISPLAY_REQUIRED;
    }
    m_previousState = SetThreadExecutionState(flags);
    m_isActive = (m_previousState != 0);
}
SleepPreventerRAII::~SleepPreventerRAII()
{
    if (m_isActive)
    {
        // 恢复正常电源管理
        SetThreadExecutionState(ES_CONTINUOUS);
    }
}

#include <iostream>
#include <thread>
#include <chrono>
#include "SleepPreventer.h"
int main()
{
    std::cout << "程序启动，阻止系统睡眠..." << std::endl;
    // 阻止系统睡眠
    if (!SleepPreventer::PreventSleep())
    {
        std::cerr << "警告：无法阻止系统睡眠！" << std::endl;
    }
    // 模拟长时间运行的任务
    for (int i = 0; i < 60; ++i)
    {
        std::cout << "运行中... " << i << " 秒" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    // 恢复正常电源管理
    SleepPreventer::AllowSleep();
    std::cout << "任务完成，恢复正常电源管理" << std::endl;
    return 0;
}

#include <iostream>
#include "SleepPreventerRAII.h"
void ProcessData()
{
    // 使用 RAII，自动管理生命周期
    SleepPreventerRAII preventer(SleepPreventerRAII::Mode::SystemOnly);
    if (!preventer.IsActive())
    {
        std::cerr << "警告：无法阻止系统睡眠！" << std::endl;
    }
    std::cout << "开始数据处理..." << std::endl;
    // 执行长时间任务
    // ... 你的业务逻辑 ...
    std::cout << "数据处理完成" << std::endl;
    // 函数返回时自动恢复电源管理（析构函数调用）
}
int main()
{
    ProcessData();
    return 0;
}

// MainWindow.h
#include <QMainWindow>
#include "SleepPreventer.h"
class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
protected:
    void showEvent(QShowEvent *event) override;
    void closeEvent(QCloseEvent *event) override;
private:
    bool m_sleepPrevented;
};

// MainWindow.cpp
#include "MainWindow.h"
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , m_sleepPrevented(false)
{
}
MainWindow::~MainWindow()
{
    if (m_sleepPrevented)
    {
        SleepPreventer::AllowSleep();
    }
}
void MainWindow::showEvent(QShowEvent *event)
{
    QMainWindow::showEvent(event);
    // 窗口显示时阻止睡眠
    if (SleepPreventer::PreventSleepAndDisplay())
    {
        m_sleepPrevented = true;
        qDebug() << "已阻止系统睡眠";
    }
}
void MainWindow::closeEvent(QCloseEvent *event)
{
    // 窗口关闭时恢复
    if (m_sleepPrevented)
    {
        SleepPreventer::AllowSleep();
        m_sleepPrevented = false;
        qDebug() << "已恢复正常电源管理";
    }
    QMainWindow::closeEvent(event);
}

// MainDlg.cpp
#include "SleepPreventer.h"
BOOL CMainDlg::OnInitDialog()
{
    CDialogEx::OnInitDialog();
    // 对话框初始化时阻止睡眠
    if (SleepPreventer::PreventSleep())
    {
        TRACE(_T("已阻止系统睡眠\n"));
    }
    else
    {
        AfxMessageBox(_T("警告：无法阻止系统睡眠！"));
    }
    return TRUE;
}
void CMainDlg::OnDestroy()
{
    // 对话框销毁时恢复
    SleepPreventer::AllowSleep();
    TRACE(_T("已恢复正常电源管理\n"));
    CDialogEx::OnDestroy();
}

// 检查返回值
uint result = SetThreadExecutionState(...);
if (result == 0)
{
    // 失败，获取错误码
    int error = Marshal.GetLastWin32Error();
}

# 查看哪些程序正在阻止睡眠
powercfg /requests

DISPLAY:
[PROCESS] \Device\HarddiskVolume3\Program Files\MyApp\MyApp.exe

SYSTEM:
[PROCESS] \Device\HarddiskVolume3\Program Files\MyApp\MyApp.exe

# 需要管理员权限
powercfg /h off
powercfg /change standby-timeout-ac 0

// 检测电源状态
if (SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online)
{
    // 接通电源，阻止睡眠
    SleepPreventer.PreventSleep();
}
else
{
    // 使用电池，允许睡眠以节能
    SleepPreventer.AllowSleep();
}

// 错误示例：多个线程同时设置可能冲突
Thread thread1 = new Thread(() => {
    SleepPreventer.PreventSleep();
    DoWork1();
    SleepPreventer.AllowSleep(); // ⚠️ 会影响其他线程
});
Thread thread2 = new Thread(() => {
    SleepPreventer.PreventSleep();
    DoWork2();
    // thread1 调用 AllowSleep 后，这里的设置会被清除
});

// 在主线程统一管理
public class PowerManager
{
    private static int _preventCount = 0;
    private static readonly object _lock = new object();
    public static void PreventSleep()
    {
        lock (_lock)
        {
            if (_preventCount == 0)
            {
                SetThreadExecutionState(
                    ES_CONTINUOUS | ES_SYSTEM_REQUIRED
                );
            }
            _preventCount++;
        }
    }
    public static void AllowSleep()
    {
        lock (_lock)
        {
            _preventCount--;
            if (_preventCount <= 0)
            {
                _preventCount = 0;
                SetThreadExecutionState(ES_CONTINUOUS);
            }
        }
    }
}

# 查看活动的电源请求
powercfg /requests
# 查看组策略设置
gpedit.msc → 计算机配置 → 管理模板 → 系统 → 电源管理

// 保持显示器开启，确保远程桌面可用
SleepPreventer.PreventSleep(SleepPreventer.PreventMode.SystemAndDisplay);

gpedit.msc → 计算机配置 → 管理模板 → Windows 组件 → 远程桌面服务
→ 远程桌面会话主机 → 连接 → "允许用户通过使用远程桌面服务远程连接" → 已启用