如何在执行期间停止机器休眠/休眠

I have an app written in golang (partially), as part of its operation it will spawn an external process (written in c) and begin monitoring. This external process can take many hours to complete so I am looking for a way to prevent the machine from sleeping or hibernating whilst processing.

I would like to be able to then relinquish this lock so that when the process is finished the machine is allowed to sleep/hibernate

I am initially targeting windows, but a cross-platform solution would be ideal (does nix even hibernate?).

On Windows, your first step is to try SetThreadExecutionState:

Enables an application to inform the system that it is in use, thereby preventing the system from entering sleep or turning off the display while the application is running

This is not a perfect solution but I assume this is not an issue for you:

The SetThreadExecutionState function cannot be used to prevent the user from putting the computer to sleep. Applications should respect that the user expects a certain behavior when they close the lid on their laptop or press the power button

The Windows 8 connected standby feature is also something you might need to consider. Looking at the power related APIs we find this description of PowerRequestSystemRequired:

The system continues to run instead of entering sleep after a period of user inactivity.

This request type is not honored on systems capable of connected standby. Applications should use PowerRequestExecutionRequired requests instead.

If you are dealing with tablets and other small devices then you can try to call PowerSetRequest with PowerRequestExecutionRequired to prevent this although the description of that is also not ideal:

The calling process continues to run instead of being suspended or terminated by process lifetime management mechanisms. When and how long the process is allowed to run depends on the operating system and power policy settings.

You might also want to use ShutdownBlockReasonCreate but I'm not sure if it blocks sleep/hibernate.

Thanks to Anders for pointing me in the right direction - I put together a minimal example in golang (see below).

Note: polling to reset the timer seems to be the only reliable method, I found that when trying to combine with the continuous flag it would only take effect for approx 30 seconds (no idea why), having said that polling on this example is excessive and could probably be increased to 10 mins (since min hibernation time is 15 mins)

Also FYI this is a windows specific example:

package main

import (
    "log"
    "syscall"
    "time"
)

// Execution States
const (
    EsSystemRequired = 0x00000001
    EsContinuous     = 0x80000000
)

var pulseTime = 10 * time.Second

func main() {
    kernel32 := syscall.NewLazyDLL("kernel32.dll")
    setThreadExecStateProc := kernel32.NewProc("SetThreadExecutionState")

    pulse := time.NewTicker(pulseTime)

    log.Println("Starting keep alive poll... (silence)")
    for {
        select {
        case <-pulse.C:
            setThreadExecStateProc.Call(uintptr(EsSystemRequired))
        }
    }
}

The above is tested on win 7 and 10 (not tested on Win 8 yet - presumed to work there too).

Any user request to sleep will override this method, this includes actions such as shutting the lid on a laptop (unless power management settings are altered from defaults)

The above were sensible behaviors for my application.