标签: event-loop

我需要知道ios生命周期中的事件循环是什么吗？任何人都可以建议我这个吗？

我的Eclipse用于开发Android应用程序.它工作正常,直到有一天,一个Unhandled事件循环异常是提示.日志如下所示.

要触发错误提示,只需将文本编辑器在eclipse中取消聚焦并再次聚焦,然后触发提示,例如,单击Package explorer(红色圆圈)并单击Main.java中的代码(绿色圆圈).日食.(.xml是相同的).

但是,如果我通过单击Package Explorer(红色圆圈)取消代码的焦点,然后单击代码的标题(蓝色圆圈),然后单击代码(绿色圆圈),将不会提示错误.

PS使用Eclipse可以编译Android应用程序并在设备中正常工作.但错误提示非常烦人.

![在此处输入图像说明] [1]

我试过了:

1. 从Android开发人员下载新的ADT(Eclipse)表单并解压缩它,不工作,仍然没有更多的句柄

2. 下载Eclipse Standard 4.3.1并解压缩,无法正常工作

3. 重启计算机,重启Eclipse.不工作

4. 创建一个新的Windows 7帐户,并使用新帐户打开相同的eclipse(在旧帐户中抛出错误)与相同的工作区,它的工作原理.没有例外.

5. 我试图用C:\ oldUser.android替换C:\ oldUser.android,旧用户仍然例外

6. 更改首选项>常规>编辑器>文件关联>*.xml和Android Manifest中的默认编辑器,无法正常工作

7. 在Eclipse中重置透视图,无法正常工作

8. 更改工作区并使用新工作区,而不是工作

我想使用旧用户帐户正确打开Eclipse.真奇怪.请帮忙.非常感谢你!!

org.eclipse.swt.SWTError: No more handles
    at org.eclipse.swt.SWT.error(SWT.java:4387)
    at org.eclipse.swt.SWT.error(SWT.java:4276)
    at org.eclipse.swt.SWT.error(SWT.java:4247)
    at org.eclipse.swt.widgets.Widget.error(Widget.java:468)
    at org.eclipse.swt.widgets.Control.createHandle(Control.java:704)
    at org.eclipse.swt.widgets.Label.createHandle(Label.java:199)
    at org.eclipse.swt.widgets.Control.createWidget(Control.java:744)
    at org.eclipse.swt.widgets.Control.<init>(Control.java:112)
    at org.eclipse.swt.widgets.Label.<init>(Label.java:101)
    at org.eclipse.ui.texteditor.StatusLineContributionItem.fill(StatusLineContributionItem.java:182)
    at org.eclipse.jface.action.SubContributionItem.fill(SubContributionItem.java:59)
    at org.eclipse.jface.action.StatusLineManager.update(StatusLineManager.java:327)
    at org.eclipse.ui.internal.WorkbenchPage.updateActivations(WorkbenchPage.java:265)
    at org.eclipse.ui.internal.WorkbenchPage.access$15(WorkbenchPage.java:243)
    at org.eclipse.ui.internal.WorkbenchPage$E4PartListener.partActivated(WorkbenchPage.java:172)
    at org.eclipse.e4.ui.internal.workbench.PartServiceImpl$2.run(PartServiceImpl.java:193)
    at org.eclipse.core.runtime.SafeRunner.run(SafeRunner.java:42)
    at org.eclipse.e4.ui.internal.workbench.PartServiceImpl.firePartActivated(PartServiceImpl.java:191)
    at org.eclipse.e4.ui.internal.workbench.PartServiceImpl.activate(PartServiceImpl.java:596)
    at org.eclipse.e4.ui.internal.workbench.PartServiceImpl.activate(PartServiceImpl.java:549)
    at org.eclipse.e4.ui.internal.workbench.swt.AbstractPartRenderer.activate(AbstractPartRenderer.java:105)
    at org.eclipse.e4.ui.workbench.renderers.swt.ContributedPartRenderer$1.handleEvent(ContributedPartRenderer.java:61)
    at org.eclipse.swt.widgets.EventTable.sendEvent(EventTable.java:84)
    at org.eclipse.swt.widgets.Widget.sendEvent(Widget.java:1053)
    at org.eclipse.swt.widgets.Widget.sendEvent(Widget.java:1077)
    at org.eclipse.swt.widgets.Widget.sendEvent(Widget.java:1058) …

在 JavaScript 中，事件循环用于引擎中。下面是一张图表来说明这篇文章。

_{（来源：mybalsamiq.com）}

对于 Node.js，事件循环也在此处实现。引用这个问题。

Node.js 事件循环在单线程下运行，这意味着您编写的应用程序代码在单线程上进行评估。Nodejs 本身通过 libuv 使用了许多线程，但是在编写 nodejs 代码时您永远不必处理这些线程。

然而，关于 node.js 事件循环对我来说仍然是抽象的。

• 有没有图片可以更清楚的介绍一下？
• 这两个事件循环有什么不同？

我正在MDN 文档上学习 JavaScript 的事件循环 。它提到队列中的消息会运行到完成，但最后它说事件循环永远不会被阻塞。我实在不明白这一点。这不是矛盾吗？请帮助我理解它们之间的区别。

“运行至完成”

每条消息都会在处理任何其他消息之前完成处理。在推理程序时，这提供了一些很好的属性，包括每当函数运行时，它都不能被抢占，并且将在任何其他代码运行之前完全运行（并且可以修改函数操作的数据）。这与 C 不同，例如，如果一个函数在线程中运行，则运行时系统可能会在任何时候停止它以在另一个线程中运行其他代码。

此模型的缺点是，如果消息需要很长时间才能完成，Web 应用程序将无法处理单击或滚动等用户交互。浏览器通过“脚本运行时间太长”对话框来缓解这种情况。遵循的一个好习惯是缩短消息处理时间，如果可能的话将一条消息削减为多条消息。

永不阻塞

事件循环模型的一个非常有趣的属性是，与许多其他语言不同，JavaScript 永远不会阻塞。处理 I/O 通常是通过事件和回调执行的，因此当应用程序等待 IndexedDB 查询返回或 XHR 请求返回时，它仍然可以处理其他事务，例如用户输入。

假设我们有一个包含以下 JS 代码的文件：

process.nextTick(()=>{
    console.log('nextTick')
})

queueMicrotask(()=>{
    console.log('queueMicrotask')
})

console.log('console.log')

我们已经"type": "commonjs"在 package.json 中设置了模块系统

我们期望控制台输出什么？Node.js 官方文档说：

在 Node.js 事件循环的每一轮中，process.nextTick() 队列始终在微任务队列之前处理

所以，在控制台中我们期望

console.log
nextTick
queueMicrotask

那行得通。直到我将模块系统更改为"type": "module". 在那次更改之后，我不断地在 process.nextTick 之前执行queueMicrotask。控制台输出为：

console.log
queueMicrotask
nextTick

有人能解释这种行为吗？我假设这种行为在某种程度上与模块评估和执行过程有关，并且 nextTick queueMicrotask 以某种方式进入不同的事件循环滴答，因为模块意味着异步执行（在浏览器中）。尽管如此，这种猜测还是非常不稳定，从我的角度来看，这是不合逻辑的。尽管如此，我仍然没有一个合理的解释。

我在整个网络上搜索答案,但没有找到我的问题的解决方案.或许我做了,但因为我是C++/programming/Qt的初学者,我不理解它们.最接近的问题是在非Qt应用程序中使用基于Qt的DLL.我试图使用这种方法,但到目前为止还没有成功.

我尝试创建一个DLL,它是我们的USB设备的API.该库也应该适用于非Qt应用程序.我有PIMPL-ed所有Qt的东西和私有类,所以下面的代码是公共类下的一层.我正在使用QSerialPort和大量的SIGNAL/SLOT,所以我需要QCoreApplications事件循环.ReaderSerial是Qt开始的地方,它还实例化另一个QSerialPort在不同QThread中运行的类.

此时我的问题是整个事情在崩溃时崩溃:"QTimer只能用于以QThread启动的线程"

我想我的基于Qt的类如ReaderSerial不会"看到"QCoreApp事件循环或类似的东西.所以我的问题是如何为我的DLL提供QCoreApplication事件循环,所以我创建的所有基于Qt的类都可以工作,我将能够从我的DLL调用方法.

非常感谢您的回答.

reader_p.h

class ReaderPrivate
{
public:
   ReaderPrivate();
   ~ReaderPrivate();

   void static qCoreAppExec();

   ReaderSerial *readerSerial;

   void connectReader(std::string comPort);
   void disconnectReader();
};

reader.cpp

// Private Qt application
namespace QAppPriv
{
    static int argc = 1;
    static char * argv[] = {"API.app", NULL};
    static QCoreApplication * pApp = NULL;
};

ReaderPrivate::ReaderPrivate()
{
    std::thread qCoreAppThread(qCoreAppExec);
    qCoreAppThread.detach();

    readerSerial = new ReaderSerial;
}

ReaderPrivate::~ReaderPrivate()
{

    delete readerSerial;

}

void ReaderPrivate::qCoreAppExec()
{
    if (QCoreApplication::instance() == NULL)
    {
        QAppPriv::pApp = new QCoreApplication(QAppPriv::argc, QAppPriv::argv); …

我使用以下函数强制协程同步运行:

import asyncio
import inspect
import types
from asyncio import BaseEventLoop
from concurrent import futures


def await_sync(coro: types.CoroutineType, timeout_s: int=None):
    """

    :param coro: a coroutine or lambda loop: coroutine(loop)
    :param timeout_s:
    :return:
    """
    loop = asyncio.new_event_loop()  # type: BaseEventLoop
    if not is_awaitable(coro):
        coro = coro(loop)
    if timeout_s is None:
        fut = asyncio.ensure_future(coro, loop=loop)
    else:
        fut = asyncio.ensure_future(asyncio.wait_for(coro, timeout=timeout_s, loop=loop), loop=loop)
    loop.run_until_complete(fut)
    return fut.result()

def is_awaitable(coro_or_future):
    if isinstance(coro_or_future, futures.Future):
        return coro_or_future
    elif asyncio.coroutines.iscoroutine(coro_or_future):
        return True
    elif asyncio.compat.PY35 and inspect.isawaitable(coro_or_future):
        return True …

我研究了 Node.Js 中的事件循环，它以异步和非阻塞的方式工作来处理请求。有什么办法可以阻止事件循环的执行吗？

我有一堂有各种方法的课。我在该类中有一个类似的方法：

 class MyClass:

    async def master_method(self):
      tasks = [self.sub_method() for _ in range(10)]
      results = await asyncio.gather(*tasks)

    async def sub_method(self):
      subtasks = [self.my_task() for _ in range(10)]
      results = await asyncio.gather(*subtasks)

    async def my_task(self):
      return "task done"  

所以这里的问题是：

1. 使用asyncio.gather()从另一个程序调用的内部协同例程是否存在任何问题、优点/缺点asyncio.gather()？有性能问题吗？

2. 循环中所有级别的所有任务是否都以相同的优先级处理asyncio？这是否会提供与我使用单个 asyncio.gather() 调用所有协同例程相同的性能master_method？

如果使用 CommonJS 模块，使用 setImmediate 调用 setTimeout 会出现不可预测的行为。但如果切换到ESM（package.json中的“type”：“module”），它总是会在setTimeout之前执行setImmediate。

setTimeout(() => {
  console.log('timeout');
}, 0);

setImmediate(() => {
  console.log('immediate');
});

为什么会出现这种情况？这与 ESM 模块异步加载有关吗？