有没有办法将Boost.Asio与Qt4(首选)或GTK主循环集成？GTK像API一样提供poll(2),因此技术上应该是可行的.Qt提供了自己的网络层,但我更喜欢使用为Boost.Asio编写的现有代码.我想在不使用额外线程的情况下集成它们.

有没有参考如何为Qt4(首选)或GTKmm做这个？

谢谢.

编辑

我想澄清一些事情,以使答案更容易.Qt和GTKmm都提供"选择类似"功能:

• http://qt-project.org/doc/qt-5.0/qtcore/qsocketnotifier.html
• http://www.gtkmm.org/docs/glibmm-2.4/docs/reference/html/group__MainLoop.html

所以,问题是,如何将现有的"选择器/轮询器"作为反应器集成到Boost.Asio中io_service.今天,Boost.Asio可以使用select,kqueue,epoll,/ dev/poll和iocp作为reactor/proactor服务.我想将它集成到GUI框架的主循环中.

欢迎任何建议和解决方案(更好).

我知道 JavaScript 是单线程的，从技术上讲，它可以\xe2\x80\x99t 具有竞争条件，但由于异步和事件循环，它可能具有一些不确定性。这里\xe2\x80\x99s是一个过于简单的例子：

class TestClass {\n  // ...\n\n  async a(returnsValue) {\n     this.value = await returnsValue()\n  }\n  b() {\n     this.value.mutatingMethod()\n     return this.value\n  }\n  async c(val) {\n     await this.a(val)\n     // do more stuff\n     await otherFunction(this.b())\n  }\n}\n

假设b()依赖于this.value自调用 以来没有发生更改a()，并且c(val)从程序中的多个不同位置快速连续地多次调用。这是否会造成数据竞争，导致和 的this.value调用之间发生变化？a()b()

作为参考，我已经使用mutex预先解决了我的问题，但我\xe2\x80\x99一直在质疑是否存在问题。

我开始尝试在Qt中进行单元测试,并希望听到有关涉及单元测试信号和插槽的场景的评论.

这是一个例子:

我想测试的代码是(m_socket是指向QTcpSocket):

void CommunicationProtocol::connectToCamera()
{
    m_socket->connectToHost(m_cameraIp,m_port);
}

由于这是一个异步调用,我无法测试返回的值.但是,我想测试套接字在成功的connection(void connected ())上发出的响应信号是否实际发出.

我在下面写了测试:

void CommunicationProtocolTest::testConnectToCammera()
{
    QSignalSpy spy(communicationProtocol->m_socket, SIGNAL(connected()));
    communicationProtocol->connectToCamera();
    QTest::qWait(250);
    QCOMPARE(spy.count(), 1);
}

我的动机是,如果响应不会在250毫秒内发生,那就是错误的.

然而,信号永远不会被捕获,我无法确定它是否发射.但我注意到我没有在测试项目的任何地方启动事件循环.在开发项目中,事件循环以main开头QCoreApplication::exec().

总结一下,当单元测试一个依赖于信号和插槽的类时,应该在哪里

QCoreApplication a(argc, argv);
return a.exec();

在测试环境中运行？

我无法理解以下代码是如何运行的.为什么"1"在"b"之后但"h"在"3"之后？订单应该是:a,b,1,2,h,3？有些文章说"事件循环队列"和"作业队列"之间的区别导致了以下输出.但是怎么样？我已经阅读了ECMAScript 2015 - 8.4工作和工作队列的规范,想知道Promise'job是如何工作的,但这让我更加困惑.有人能帮我吗？谢谢!

var promise = new Promise(function(resolve, reject) {resolve(1)});
promise.then(function(resolve) {console.log(1)});
console.log('a');
promise.then(function(resolve) {console.log(2);});
setTimeout(function() {console.log('h')}, 0);
promise.then(function(resolve) {console.log(3)});
console.log('b');

// a
// b
// 1
// 2
// 3
// h

我知道Promise是异步的,但setTimeout(..)异步操作的回调总是在Promise的异步操作之后.为什么？

一般目标

我想知道以下javascript环境如何作为系统互连.

• Javascript引擎
• 事件循环
• 事件队列

我们可以将此限制为浏览器环境,因为节点已在另一篇文章中介绍(此处)

我(相信)理解的事情:

• Javascript是单线程的,因此只有一个callstack.

• Javascript环境只提供一些真正异步的函数.这些可能包括setTimeout(),setInterval()和I/O函数.

• 如果不使用其中一个,开发人员就无法创建自己的异步函数.
• Javascript本身同步运行,但通过它的异步函数可以在当前的callstack清除后回调可能的阻塞函数.

例:

      console.log(‘Sync code started…’);

      setTimeout(function asyncLog() {
           console.log(‘Async function has completed’)
      }, 2000);

      console.log(‘Sync code finished…')

示例步骤:

(如果我错了,请纠正步骤)

1. 记录"同步代码已启动..."
2. setTimeout被添加到堆栈但立即返回控件
3. setTimeout被发送到另一个'thread'...'worker'？在javascript的单线程之外计算2000毫秒
4. 记录"同步代码已完成..."
5. 在2000毫秒之后,asyncLog()被推送到事件队列
6. 由于callstack已清除,因此Event Loop会检查事件队列是否有待处理的回调
7. asyncLog()从队列中删除,并由事件循环推送到堆栈
8. 记录了"异步功能已完成"
9. callstack现在很清楚了

质询

如果有人可以概述async函数(例如setTimeout)从第一次访问callstack到回调到callstack的时间和位置的步骤的概述,则不需要逐个回答这些步骤.

1. 在第3步,谁产生这个新线程？是浏览器吗？
   • 这个新线程被阻止正确吗？
   • 如果你有一个创建1000 setTimeouts的循环会发生什么.是否创建了1000个"线程"？
   • 一次可以生成多少个线程是否有限制？
   • 当新线程完成执行时,它如何最终在队列中？
2. 谁提供了事件队列？
3. 谁提供事件循环？
   • 事件循环是否轮询事件队列？
   • javascript的线程是否知道事件循环？或者Event循环只是把东西推到堆栈上？
   • 事件循环如何知道堆栈何时清除？

最近,我一直在深入研究Twisted文档.从我收集的内容来看,Twisted功能的基础是它的事件循环称为"Reactor".reactor侦听某些事件并将它们分派给已设计用于处理这些事件的已注册回调函数.在书中,有一些伪代码描述了Reactor的功能,但我无法理解它,它对我没有任何意义.

 while True:
     timeout = time_until_next_timed_event()
     events = wait_for_events(timeout)
     events += timed_events_until(now())
     for event in events:
         event.process()

这是什么意思？

所以,我一直在考虑一个脑筋急转弯 - 如果我有一个大对象,我出于某种原因不得不在节点js中迭代,并且在我这样做的时候不想阻止事件循环怎么办？

这是一个非常头脑的例子,我相信它可以更清洁:

var forin = function(obj,callback){
    var keys = Object.keys(obj),
        index = 0,
        interval = setInterval(function(){
            if(index < keys.length){
                callback(keys[index],obj[keys[index]],obj);
            } else {
                clearInterval(interval);
            }
            index ++;
        },0);
}

虽然我确定它有其他原因让它变得混乱,但这会比常规for循环执行得慢,因为setInterval 0实际上并不是每隔0 ms执行一次,但是我不知道如何用很多循环来执行循环更快的process.nextTick.

在我的测试中,我发现这个例子需要7毫秒才能运行,而不是原生的for循环(使用hasOwnProperty()检查,记录相同的信息),这需要4毫秒.

那么,使用node.js编写相同代码的最干净/最快的方法是什么？

I wrote some code that has an epoll-eventloop, accepts new connections and pretends to be a http-server. The posted code is the absolute minimum ... I removed everything (including all error-checks) to make it as short and to the point as possible:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/ip.h>
#include <netinet/in.h>
#include <sys/uio.h>
#include <unistd.h>


int main () {
    int servFd = socket (AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, IPPROTO_IP);
    int value = 1;
    setsockopt …

我一直在使用GWT进行一些Web应用程序编程,并且被术语"浏览器事件循环"搞糊涂了.

我遇到过需要执行延迟命令并在浏览器事件循环完成后"执行某些操作"的情况.

我想知道它究竟是什么以及在事件循环过程中发生了什么以及以什么顺序？

我有一个Qt应用程序与这种main()...

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    MainWindow   mainWin;

    ... A separate, non-GUI thread is launched here

    mainWin.Init();
    mainWin.show();

    app.exec();
}

在mainWin需要知道何时可以开始与mainWin通信之前创建的另一个线程.但由于mainWin使用Qt信号,插槽,定时器等,因此在事件循环运行之前(通过exec()),它还没有真正准备好.

我的问题是:当事件循环开始时是否会发出一些信号或事件？

考虑一下.在mainWin.Init()中,您可以创建类似QTimer的内容,甚至可以调用.start()来启动它.但实际上它不会被运行并在调用exec()之前触发事件.这就是我需要知道事件循环何时真正开始的原因.