是否有任何Win32 API将机器置于休眠或挂起模式？

我读了MSDN,发现WM_POWERBROADCAST当电源管理事件发生时,消息会被广播.我想到了同样的模拟PostMessage(WM_POWERBROADCAST).这是正确的做法还是存在任何Win32 API来实现这一目标？

我可以使用 SuspendThread() 挂起另一个进程的线程。有没有办法完全暂停该进程的执行？如果是，请发布代码。

谢谢。

PS：既然你会问“你为什么要这样做”，我就把它贴在这里。我正在处理不再维护的遗留软件。我无权访问源代码。现在我需要它暂停，直到文件充满数据，然后恢复执行。

这个问题涉及Delphi和XE特别弃用Suspend和Resume.我已阅读其他帖子,到目前为止我还没有找到类似的用法,所以我将继续讨论并要求进行讨论.

我想知道有什么更好的方法可以在不需要时暂停线程？

我们有一个多年来使用的Delphi类,它基本上是一个与线程进程相关联的FIFO队列.队列接受主线程上的数据对象,如果线程被挂起,它将恢复它.

作为线程的Execute进程的一部分,对象从队列中弹出并在线程上处理.通常这是进行数据库查找.

在进程结束时,对象的属性将更新并标记为主线程可用或传递给另一个队列.执行过程的最后一步(实际上是第一步)是检查队列中是否还有其他项.如果有继续,否则它自行暂停.

它们是键,它在执行循环完成时是唯一的挂起操作,并且在将新项放入队列时调用正常操作期间的唯一恢复.例外是队列类被终止时.

恢复功能看起来像这样.

process TthrdQueue.MyResume();
  begin
    if Suspended then begin
      Sleep(1); //Allow thread to suspend if it is in the process of suspending
      Resume();
    end;
  end;

执行看起来与此类似

process TthrdQueue.Execute();
  var
    Obj : TMyObject;
  begin
    inherited;
    FreeOnTerminate := true;
    while not terminated do begin
      if not Queue.Empty then begin
        Obj :=  Pop();
        MyProcess(Obj);  //Do work
        Obj.Ready := true;
      end
      else
        Suspend();  // No more Work
    end;   //Queue clean up in Destructor
  end;  

TthrdQueue Push例程在堆栈中添加另一个对象后调用MyResume.如果线程被挂起,MyResume只调用Resume.

关闭时,我们将terminate设置为true,如果它被挂起则调用MyResume.

我正在使用ubuntu 12.04.有没有办法在Python中捕获暂停事件,即如果笔记本电脑暂停,请执行此操作......？捕获关闭事件的问题相同.

在正常情况下,以下代码每两分钟很好地记录:

Observable.Interval(TimeSpan.FromSeconds(120)).Subscribe(
    l =>
        {                        
            var now = DateTime.Now;
            Console.WriteLine(
                "Tick at " + now.ToString("hh:mm:ss") + " Count " + l.ToString());        
        });

设备休眠一段时间后然后恢复的行为

Tick at 11:30:00 Count 0
(11:31:55 put computer to sleep)
(no tick at 11:32:00 because PC is suspended, which is fine)
(no tick at 11:34:00 because PC is suspended)
(11:34:30 wake computer up)
(no tick as soon as possible to indicate that ticks were missed) 
Tick at 11:36:30 Count 1

似乎Observable Interval定时器类重置自身并从设备恢复时起重新开始间隔.(我观察到与Observable Timer类似的行为)

睡眠感知计时器

我需要一个不会在恢复时重启间隔的计时器,但如果在睡眠期间错过了任何刻度,则需要一次计时器

• 没有一次错过每个嘀嗒声,但是如果错过了任何数量的蜱,则总计一次
• 这对于数小时或数天的TimeSpans特别相关,在某些情况下,如果笔记本电脑每天进入睡眠状态,计时器也不会再次打勾 …

我有一个UWP应用程序,允许用户创建和修改文本文档.我很难让保存机制与app suspend/resume生命周期一起工作.

这是我有的:

1. 所有磁盘访问都在单独的后台线程上完成,以保持UI响应
2. 该后台线程还序列化所有磁盘访问,以确保始终只进行一次读取或写入操作
3. 保存文档之前和之后,UI将更新以指示正在进行保存.这是在UI线程上安排的Dispatcher.RunAsync()

当应用程序被暂停时:

• 暂停时,我必须最后一次保存文档以确保所有更改都在磁盘上(应用程序可能会在暂停时终止)
• 所以我要求一个 ExtendedExecutionSession
• 我在队列上安排了一个最终的保存操作
• 然后我等待队列处理所有挂起的磁盘访问操作
• 最后,我将扩展执行会话标记为已完成

我的问题:

• 已安排的保存操作完成其磁盘访问,然后尝试通过主线程更新UI Dispatcher.RunAsync().后台队列等待此任务完成,但它永远不会,因为到那时,UI线程已经停止.

→所以我的最终保存操作永远不会执行,因为后台队列等待更新UI.

这是一个流程图:

出现的一些问题:

1. 当应用程序被暂停时,UI线程到底是什么时候停止的？只有当它闲置或"介于两者之间"时？即如果我安排了一个块通过Dispatcher.RunAsync(),这至少会完成或"冻结"吗？
2. 有没有办法让我检查当前窗口的UI线程是否已经停止,以便我知道我不能再在后台文件访问线程中访问它了？
3. 当应用程序被暂停时,哪些线程会停止以及何时停止？
4. 应用程序暂停时,我的后台文件访问线程是否也有被阻止的风险？

总结一下这个问题:

当应用程序被暂停时,我必须确保在等待后台线程上的潜在挂起磁盘访问权限才能完成,然后我再次保存文档,以防我的应用程序稍后终止.

当我尝试模拟挂起内联函数时，看起来 coEvery 挂起。

如果删除内联修饰符，下面的代码将起作用

storeApi 中的函数： suspend inline fun getAllStores(): List<Store>

测试代码： coEvery { storeApi.getAllStores() } returns allStores

我想要一种方法来模拟挂起内联函数，而不仅仅是挂起

介绍

给定两个函数，foo()and foo()，第一个是标准的，第二个是可暂停的

fun foo(x: Int): Int {
    return 2*x
}

suspend fun foo(x: Int): Int {
    return 4*x
}

以下代码无法编译，因为具有相同签名的两个函数存在冲突。

冲突重载：public fun foo(x: Int): Int 在文件 t.kt 中定义，public suspend fun foo(x: Int): Int 在文件 t.kt 中定义

暂停功能

如果我对挂起函数的理解是正确的，那么：

1. 一个Continuation参数被添加到挂起函数中，状态机使用它来停止和启动挂起代码
2. 挂起标记函数在后台使用的返回类型是Any（因此Object对于 java）

这两个副作用理论上应该足以改变第二个foo()函数签名，因此以不同于第一个的方式看待挂起标记的函数。

分析

起初，我认为函数签名检查可以在实际将代码编译成字节码之前进行。然而，将两个呈现的函数变成实际的字节码实际上会导致 2 个具有 2 个不同签名的方法。

Java：t.kt -> t.decompiled.java

@Metadata(
    mv = {1, 1, 16},
    bv = {1, 0, 3},
    k = 2,
    d1 …

看这个例子：

fun f(block: suspend () -> Unit) {
    println("with suspend")
}

fun f(block: () -> Unit) {
    println("without suspend")
}

fun main() {
    f(suspend {
    })

    // This call cause compilation error:
    // Error:(16, 5) Kotlin: Overload resolution ambiguity:
    // public fun f(block: () -> Unit): Unit defined in root package in file Main.kt
    // public fun f(block: suspend () -> Unit): Unit defined in root package in file Main.kt
    //
    // f({
    // })

    // This call cause compilation …

假设我们有一个函数

suspend fun doSomething(value: Int): String {
    delay(1000L)
    return "abc_$value"
}

如何将其转换为返回的函数Mono？在属于协程范围的线程和反应器事件循环线程之间切换是否存在任何隐藏问题？

fun resultAsMono(fn: suspend (Int) -> String): (Int) -> Mono<String> {
   // ???
}

那么效果会是这样的：

val newFn = resultAsMono(::doSomething)

val result = newFn(5).block()

assertThat(result).isEqualTo("abc_5")