标签: event-loop

是否可以查看事件循环以进行诊断？

我想知道当前有多少事件正在等待执行(不包括setTimeout/interval).

更新:我想从正在运行的节点进程中执行此操作.

我想监视node.js中每次运行事件循环的时间.但是我不确定衡量这一点的最佳方法.我能想出的最佳方式如下:

var interval = 500;
var interval = setInterval(function() {
    var last = Date.now();        
    setImmediate(function() {
        var delta = Date.now() - last;
        if (delta > blockDelta) {
            report("node.eventloop_blocked", delta);
        }
    });
}, interval);

我基本上通过查看a的延迟来推断事件循环运行时间setInterval.我在阻塞节点模块中看到了相同的方法,但感觉不准确和沉重.有没有更好的方法来获取这些信息？

更新:更改了代码,以便setImmediate像hapi.js一样使用.

我在事件循环中读过几个帖子/ SO线程,根据MDN的文章,

当堆栈为空时,将从队列中取出一条消息并进行处理.

作为一个JS新手,我仍然感到困惑的是 - 什么时候调用堆栈变得"空"？例如,

<script>
function f() {
  console.log("foo");
  setTimeout(g, 0);
  console.log("foo again");
}
function g() {
  console.log("bar");
}
function b() {
  console.log("bye");
}

f();
/*<---- Is the stack empty here? */
b();
</script>

正确的执行顺序是foo- foo again- bye- bar.

但是今天我开始思考:退出f()电话后,技术上的堆栈是不是很空？我的意思是在那一点上我们不在任何函数内部,并且我们还没有开始任何新的执行,所以不应该处理setTimeout调用消息(已经立即排队),然后继续执行b(),并给出顺序foo- foo again- bar- bye？

如果我们有一百万行代码或一些密集计算要执行并且setTimeout(func, 0)只是在队列中停留多长时间怎么办？

在这个问题的回答中——

Node.js 中的非阻塞或异步 I/O 是什么？

这个描述听起来与普通 js 中的事件循环没有什么不同。两者有区别吗？如果不是，事件循环是否只是简单地重新命名为“异步非阻塞 I/O”，以便更容易地销售 Node.js 而不是其他选项？

我们已经实现了对Netty事件循环队列的监控,以便了解我们的一些Netty模块的问题.监视器使用的io.netty.util.concurrent.SingleThreadEventExecutor#pendingTasks方法适用于大多数模块,但对于每秒处理几千个HTTP请求的模块,它似乎挂起或非常慢.我现在意识到文档严格规定这可能是一个问题,我觉得很蹩脚......所以我正在寻找另一种方法来实现这个监视器.

你可以在这里看到旧代码:https: //github.com/outbrain/ob1k/blob/6364187b30cab5b79d64835131d9168c754f3c09/ob1k-core/src/main/java/com/outbrain/ob1k/common/metrics/NettyQueuesGaugeBuilder.java

  public static void registerQueueGauges(final MetricFactory factory, final EventLoopGroup elg, final String componentName) {

    int index = 0;
    for (final EventExecutor eventExecutor : elg) {
      if (eventExecutor instanceof SingleThreadEventExecutor) {
        final SingleThreadEventExecutor singleExecutor = (SingleThreadEventExecutor) eventExecutor;
        factory.registerGauge("EventLoopGroup-" + componentName, "EventLoop-" + index, new Gauge<Integer>() {
          @Override
          public Integer getValue() {
            return singleExecutor.pendingTasks();
          }
        });

        index++;
      }
    }
  }

我的问题是,是否有更好的方法来监控队列大小？

这可能是一个非常有用的指标,因为它可用于理解延迟,并且在某些情况下也可用于施加背压.

基本上调用栈将开始流行了函数调用一个接一个,当最后的函数调用返回.但是当我尝试创建一个接近其最大值的调用堆栈时,An uncaught expression就会被提升.

//Code for testing the stack size
var cnt = 0;

function test(){
 //Max stack size is nearer to ~41800
 if(cnt++ == 41763){
  console.log('finished');
  return true;
 }
 return test();
}

test();

所以上面的代码在我的Chrome版本49.0.2623.112 m中给我一个例外,如下所示,

未捕获的异常

<true

请注意,上述错误中没有消息.我的问题是,

堆栈中的最后一个函数调用已返回true,这意味着未超出堆栈大小.为什么没有返回该堆栈中的其他函数调用？这个空白异常消息的原因是什么？

下图取自Jon Resig所着的" Jinja of JavaScript Ninja "一书的第3章.这里作者解释了浏览器事件循环.

这本书不得不说:

重要的是要注意将事件放入队列的浏览器机制在此事件循环模型的外部.确定事件何时发生并将其推送到事件队列所需的处理不参与处理事件的线程.

所以我的问题是,说浏览器中的JavaScript是单线程的吗？我问这个问题,因为显然有两个单独的任务(处理事件和事件排队在这里并行进行).

我想在Executor中使用asyncio调用loop.run_in_executor启动阻塞函数,然后稍后取消它,但这对我来说似乎不起作用.

这是代码:

import asyncio
import time

from concurrent.futures import ThreadPoolExecutor


def blocking_func(seconds_to_block):
    for i in range(seconds_to_block):
        print('blocking {}/{}'.format(i, seconds_to_block))
        time.sleep(1)

    print('done blocking {}'.format(seconds_to_block))


@asyncio.coroutine
def non_blocking_func(seconds):
    for i in range(seconds):
        print('yielding {}/{}'.format(i, seconds))
        yield from asyncio.sleep(1)

    print('done non blocking {}'.format(seconds))


@asyncio.coroutine
def main():
    non_blocking_futures = [non_blocking_func(x) for x in range(1, 4)]
    blocking_future = loop.run_in_executor(None, blocking_func, 5)
    print('wait a few seconds!')
    yield from asyncio.sleep(1.5)

    blocking_future.cancel()
    yield from asyncio.wait(non_blocking_futures)



loop = asyncio.get_event_loop()
executor = ThreadPoolExecutor(max_workers=1)
loop.set_default_executor(executor)
asyncio.async(main())
loop.run_forever()

我希望上面的代码只允许阻塞函数输出:

blocking 0/5
blocking …

在Windows上使用Python 3.4.1,我发现在执行asyncio事件循环时,我的程序不能被中断(即在终端中按Ctrl + C).更重要的是,SIGINT信号被忽略.相反,我已经确定在不在事件循环中时处理SIGINT.

为什么执行asyncio事件循环时会忽略SIGINT？

下面的程序应该演示问题 - 在终端中运行它并尝试通过按Ctrl + C来停止它,它应该继续运行:

import asyncio
import signal


# Never gets called after entering event loop
def handler(*args):
    print('Signaled')


signal.signal(signal.SIGINT, handler)

print('Event loop starting')
loop = asyncio.SelectorEventLoop()
asyncio.set_event_loop(loop)
loop.run_forever()
print('Event loop ended')

请参阅官方(郁金香)邮件列表上的讨论.

我已经了解了Microtasks和Macrotasks的概念已有一段时间了,从我读过的所有内容中,我一直认为setTimeout会创建一个macrotask和Promise.resolve()(或process.nextTick在NodeJS上)来创建微任务.

(是的,我知道像Q和Bluebird这样的不同Promise库有不同的调度程序实现,但这里我指的是每个平台上的本机Promises)

考虑到这一点,我无法解释NodeJS上的以下事件序列(Chrome上的结果与NodeJS(v8 LTS和v10)不同,并且符合我对此主题的理解).

for (let i = 0; i < 2; i++) {
	setTimeout(() => {
		console.log("Timeout ", i);
		Promise.resolve().then(() => {
			console.log("Promise 1 ", i);
		}).then(() => {
			console.log("Promise 2 ", i);
		});
	})
}

因此,我在Chrome上的结果(与我对Micro/Macro任务的理解以及Promise.resolve和setTimeout的行为方式一致)是:

Timeout  0
Promise 1  0
Promise 2  0
Timeout  1
Promise 1  1
Promise 2  1

在NodeJS输出上执行的代码相同:

Timeout  0
Timeout  1
Promise 1  0
Promise 2  0
Promise 1  1
Promise 2  1

我正在寻找一种在Chrome上使用NodeJS获得相同结果的方法.我也用测试process.nextTick代替, …