标签: event-loop

我正在建立一个单人游戏MUD,它基本上是一个基于文本的战斗游戏.它没有联网.

我不明白如何收集用户命令并将它们异步传递到我的事件循环中.当游戏事件发生时,玩家需要能够随时输入命令.因此,使用raw_input暂停该过程将不起作用.我想我需要做一些像select.select和使用线程的东西.

在下面的示例中,我有一个userInputListener()的模型函数,我喜欢接收命令,如果有输入,则将它们附加到命令Que.

如果有一个事件循环,例如:

from threading import Timer
import time

#Main game loop, runs and outputs continuously
def gameLoop(tickrate):

    #Asynchronously get some user input and add it to a command que 
    commandQue.append(userInputListener())
    curCommand = commandQue(0)
    commandQue.pop(0)

    #Evaluate input of current command with regular expressions
    if re.match('move *', curCommand):
        movePlayer(curCommand)
    elif re.match('attack *', curCommand):
        attackMonster(curCommand)
    elif re.match('quit', curCommand):
        runGame.stop()
    #... etc    

    #Run various game functions...
    doStuff()

    #All Done with loop, sleep
    time.sleep(tickrate)

#Thread that runs the game loop
runGame = Timer(0.1, …

我一直在阅读一些NodeJs文章,以了解它的异步性质,在此期间我发现了这个并且非常喜欢它Node.js,Doctor's Offices and Fast Food Restaurants - 了解事件驱动编程

有一种叫做EventLoop基于FIFO的队列.他们说当异步函数被击中时,它会被放到EventLoop并继续在那里执行.

我在这里有点困惑.例如,这里说:

实际上,setTimeout和setInterval等异步函数被推送到称为事件循环的队列中.

在同一篇文章中:

Event Loop是一个回调函数队列.执行异步函数时,回调函数将被推入队列.在执行异步函数之后的代码之前,JavaScript引擎不会开始处理事件循环.

但它与此图像不同:

我们来看下面的例子:

console.log("Hello,");
setTimeout(function(){console.log("World");},0);

从我从那些不同的解释中理解的,

1. 首先说function(){console.log("World");}的是setTimeout()函数的一部分,即回调,将放在EventLoop中.一旦setTimeout完成,它也将执行EventLoop.
2. 另一个说,整个事情setTimeout(function(){console.log("World");},0);将被放到EventLoop并将被执行...

我现在更加困惑了.它应该是简单的东西,但我想一个好但简单的解释对我来说对以下问题很好:

1. 上述哪一项是真的？
2. 什么是EventLoop？比喻,方法,对象等真实的东西？
3. 如果我想从头开始实现与EventLoop类似的东西,它会如何简单？也许一些代码会很高兴看到.

我已了解以下有关 QApplicationexec功能的信息：

QApplication exec 启动主事件循环。它启动 GUI。它处理信号并在接收到它们时调用适当的时隙。它一直等到 exit 被调用并返回在 exit 中设置的值。

现在，当我们说事件循环时，是否意味着在 Qt 的内部代码中运行了一些 while 循环，并且在那个 while 循环中编写了处理信号和槽的方法？

我有一个关于 pythonasyncio模块中的事件循环如何管理未完成任务的问题。考虑以下代码：

import asyncio

@asyncio.coroutine
def a():
   for i in range(0, 3):
      print('a.' + str(i))
      yield


@asyncio.coroutine
def b():
   for i in range(0, 3):
      print('b.' + str(i))
      yield


@asyncio.coroutine
def c():
   for i in range(0, 3):
      print('c.' + str(i))
      yield


tasks = [
   asyncio.Task(a()),
   asyncio.Task(b()),
   asyncio.Task(c()),
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait([t1, t2, t3]))

运行这将打印：

a.0
b.0
c.0
a.1
b.1
c.1
a.2
b.2
c.2

请注意，它总是打印出 'a' 然后是 'b' 然后是 'c'。我猜无论每个协程经过多少次迭代，它都将始终按该顺序打印。所以你永远不会看到类似的东西

b.100
c.100
a.100

来自 node.js 背景，这告诉我这里的事件循环在内部维护一个队列，它用来决定接下来运行哪个任务。它最初放在a()队列的前面，然后是b() …

Node.js维护一个事件循环，但是默认情况下，它还具有四个线程来处理复杂的请求。当线程池中有更多可用线程时，如何使用单线程？

而且，事件循环为复杂任务分配的线程是专用线程，那么它与其他多线程概念有何不同？

通过阅读许多JavaScript Event Loop教程，我看到了不同的术语来标识队列，这些队列存储了当Call Stack为空时准备由Event Loop提取的消息：

• 队列
• 消息队列
• 事件队列

我找不到规范的术语来识别这一点。

甚至MDN在“事件循环”页面上似乎也很困惑，因为它首先将其称为“ 队列”，然后说“ 消息队列”，但是在标签中我看到了“ 事件队列”。

循环的这一部分是在详细信息的某个地方定义的，还是仅仅是一个没有“固定”名称的实现细节？

目前,我试图使人们有可能删除工作通过排队post或者dispatch到io_context.这项工作由少量的库格组排队,工作可以一次性删除:

boost::asio::io_context context;

auto work = [] {
  // ...
};
boost::asio::post(context, std::move(work));

// ... now I want to remove the work

是否有asio库提供的功能？

目前我正在使用的应用程序是使用io_context::run()从多个线程调用的线程池.

我的想法是,我可以创建io_context由线程池调度的多个s,以便一个io_context代表可以通过删除的组io_context::stop().所有io_contexts都将被保存在一个列表中,然后汇集到一个列表中以用于未完成的事件.

但是我相信汇集或等待很多人io_context可能会导致性能问题.有不同的解决方案吗？

我正在使用事件asyncio forever()循环。现在我想在进程或信号或文件更改后重新启动循环（停止循环并重新创建一个新循环），但我有一些问题要做：

下面是三个简化的代码片段，其中演示了一些协程工作器和一个协程循环重启器：

#第一次尝试：

import asyncio

async def coro_worker(proc):
    print(f'Worker: {proc} started.')
    while True:
        print(f'Worker: {proc} process.')
        await asyncio.sleep(proc)

async def reset_loop(loop):
    # Some process
    for i in range(5):  # Like a process.
        print(f'{i} counting for reset the eventloop.')
        await asyncio.sleep(1)

    main(loop)  # Expected close the current loop and start a new loop!

def main(previous_loop=None):
    offset = 0
    if previous_loop is not None:  # Trying for close the last loop if exist.
        offset = 1  # An offset …

使用 async/await 函数时调用堆栈的行为如何？

function resolveAfter2Seconds() { // taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function
  return new Promise(resolve => {
    setTimeout(() => {
      resolve('resolved');
    }, 2000);
  });
}

const asyncFuntion=async()=>{
  const result = await resolveAfter2Seconds();
  console.info("asyncFuntion finish, result is: ", result);
}

const first = async()=>{
    await asyncFuntion();
    console.log('first completed');
        debugger;
}

const second = ()=>{
    console.log('second completed');
        debugger;
}

function main(){
    first();
    second();
}


main();

在上面的代码中，当在 second() 中遇到第一个断点时，我可以看到调用堆栈包含 main() 和 second()。在 first() 的第二个断点期间，调用堆栈包含 main() 和 first()。

在第一个断点期间 first() 发生了什么。它被推到哪里去了？假设 asyncFunction() 需要一些时间才能完成。

有人请帮忙。

我在检查事件循环中的值时尝试使用匹配大小写。然而break，不仅打破了匹配情况，而且也打破了事件循环。

这是代码

while True:
    # Some code stuff here
    if event == "#PassSign":
        # Some code stuff again to check password strength
        # Display the password strength
        match strength_pass:
            case 0:
                window["#StatusPassSign"].update("No Password", visible=True)
                break
            case 1:
                window["#StatusPassSign"].update("Password Strength: Low", visible=True)
                break
            case 2:
                window["#StatusPassSign"].update("Password Strength: Medium", visible=True)
                break
            case 3:
                window["#StatusPassSign"].update("Password Strength: High", visible=True)
                break

如何在不停止事件循环的情况下中断/停止比赛？