标签: event-loop

我有一个简单的 winit 应用程序，它创建一个空窗口并运行 EventLoop：

event_loop.run(move |event, _, control_flow| {
    control_flow.set_wait_until(std::time::Instant::now() + Duration::from_millis(1000));
    match event {
        Event::WindowEvent{ ref event, window_id, } => {},
        Event::MainEventsCleared => {
            window.request_redraw()
        },
        _ => {}
    }
});

在 MacOS 上，此进程 100% 使用 1 个 CPU 核心。如果我删除 window.request_redraw 调用，或者当我人为地限制线程睡眠时（无论设置等待直到控制流程），CPU 使用率会急剧下降到 10% 左右。这表明 wait/wait Until 无法正常工作，因为如果我理解正确的话，我希望每 1 秒才会看到对 request_redraw 的调用。

除了 thread::sleep/wait/wait Until 之外，还有什么方法可以限制事件循环运行频率，或者我做错了什么？

今天我在接受采访时被问到这个问题。我无法回答这个问题，面试官说有一个特殊的队列用于 requestAnimationFrame 回调。但我找不到任何这方面的信息。

如果 rAF 有它自己的队列，那么为什么这个队列从未在任何地方被提及？当我们谈论事件循环时，我们只提到宏任务队列和微任务队列？

如何记录Objective-C事件循环的单次迭代中发送的每条消息？

我希望进一步了解Objective-C运行时,并认为这将是一个良好的开端.

我是GTK的新手,我偶然发现了一个听起来简单的问题,但我找不到解决问题的方法.基本上,调用gtk.main()使我的单线程进程停止.我知道这gtk.main()是阻塞的,但我之前没有打过电话gtk.main(),所以退出主循环不会有任何好处,因为没有循环退出.

即便如此,gtk.main_level()返回0.此外,当我gtk.main()从python命令行尝试时,它也会挂起.我缺少一些基本的东西,有人能指出这个吗？赞赏.

编辑:我需要的Gtk方法是gobject.add_timeout这样的:

gobject.timeout_add(2000, callback)
gtk.main() # This blocks the thread.

我有一个以下的情况.

• Socket主for循环中创建了2个对象(原始问题有1000个对象).在创建时,start()调用该方法.
• start()创建一个QTcpSocket尝试连接到某个主机的.
• Socket有插槽connected()从QTcpSocket 捕获信号并打印一些调试输出

所发生的事情是按时间顺序首先Socket创建所有对象,然后启动套接字.以下是调试选项的示例输出:

1. Created Socket object 1
2. Invoked Socket object 1 start()
3. Created Socket object 2
4. Invoked Socket object 2 start()
5. Socket object 1 TcpSocket Connected
6. Socket object 2 TcpSocket Connected

码:

//main.cpp
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    for (int i=0; i<10; i++)
    {
        Socket *socket = new Socket();
        qDebug() << "Socket …

我在代码中创建了一个难以追踪的错误，但不明白为什么会发生。当多次推送相同的异步函数以立即调用时会出现问题。同步函数不会发生这种情况。

这是该问题的运行示例：

import asyncio
import sys

class TestObj(object):

    def __init__(self):

        self.test_data = {'a': 1, 'b': 2, 'c': 3}
        self.loop = asyncio.get_event_loop()
        self.loop.call_later(1, lambda: asyncio.ensure_future(self.calling_func()))
        self.loop.call_later(2, self.calling_func_sync)
        self.loop.call_later(4, sys.exit)
        self.loop.run_forever()

    async def do_something(self, k, v):
        print("Values", k, v)

    async def calling_func(self):
        for k, v in self.test_data.items():
            print("Sending", k, v)
            self.loop.call_soon(lambda: asyncio.ensure_future(self.do_something(k, v)))

    def do_something_sync(self, k, v):
        print("Values_sync", k, v)

    def calling_func_sync(self):
        for k, v in self.test_data.items():
            print("Sending_sync", k, v)
            self.loop.call_soon(self.do_something_sync, k, v)


if __name__ == "__main__":
    a = TestObj()

输出是：

Sending …

setTimeout下面是同步代码之后执行的例子

console.log('hello');
setTimeout(() => console.log('timeout'), 0);
console.log('end');

控制台输出：hello end timeout

异步：

function asyncForEach(array, callBack) {
    array.forEach(x => setTimeout(callBack(x), 0));
}
asyncForEach([1,2,3,4], (i) => console.log(i)); 
console.log('end');

控制台输出：

1
2
3
4
end

同步：

[1,2,3,4].forEach(x => console.log(x));
console.log('end');

控制台输出：

1
2
3
4
end

我试图更好地理解event loop和task queue，并且在观看了一个很好的推荐视频（https://www.youtube.com/watch?v=8aGhZQkoFbQ）后，遇到了以下半声明：“回调可以是同步和异步的”。演讲者继续演示同步方式如何最终不会通过task queue，因此不会通过event loop，因此所有内容都保留在stack. 但是，异步方式会导致task queue用 的最终返回填充setTimeout callback，这将使任何同步的下面代码可执行，因为event loop必须等待一个空stack来插入返回的callback.

运行上面的代码时（我从他那里偷来的东西也编辑过，所以这可能是我的错误添加），异步方式产生与同步方式相同的结果。

有人可以帮助解释为什么异步方式不作为第一个setTimeout示例和/或提供解释如何不将常规回调（例如数组帮助程序方法）插入task …

Dart 如何在不阻塞的情况下运行异步代码？例如：

void test(User user) async {
    print('test');

    String fullName = user.firstName + ' ' + user.lastName;

    final result = await sendRequest(fullName);

    print('${result}');
}

我知道当 Dart 运行 async 函数时，它会在 await 之前执行代码，然后将剩余的代码包装到 Future 中并将其放入事件循环中。但是，我们正在等待的 Future ( await sendRequest(fullName)) 如何不阻塞运行另一个同步代码？我们应该等待请求完成，但它也需要一些代码来检查我们是否收到或未收到响应。它如何不阻止其他操作，例如按钮单击？

JavaScript 代码在单线程上运行，在事件循环中，当方法推送到 Web api 时，将回调函数返回到队列，侦听器队列和调用堆栈为空推送回调函数在调用堆栈中执行它，因此异步执行实际上只是更改了功能？为什么？