Flutter为什么不需要子线程——Dart IO源码剖析（下）

Dart IO源码剖析（下）

在上一篇文章中，我们详细剖析了Dart 的文件IO，这一章，我们将剖析Dart 网络IO。

网络IO

基于上篇的基础，我们已经大概知道Dart VM的一些知识，那么这篇文章，我就不会解释得过于细致了。

还是让我们先从Dart代码开始吧！

var httpClient = HttpClient();
// 发起 GET 请求
var request = await httpClient.getUrl(Uri.parse('http://example.com/data.json'));
// 等待服务器响应
var response = await request.close();
// 如果请求成功（HTTP 状态码为 200）
if (response.statusCode == HttpStatus.ok) {
   // TODO:
}

以上是不借助第三方库，直接使用Dart 标准库发起HTTP请求的Demo。我们知道，HTTP其实也是建立在TCP的基础之上的，Dart中的HTTP网络请求，也是封装的Socket 接口，当然，还有一系列对HTTP协议的实现，但我们去查看HttpClient的实现，会发现里面就是调用的Socket发送数据。那么我们再看以下Dart中的Socket编程的Demo：

// 连接服务器的8081端口
Socket socket = await Socket.connect('127.0.0.1', 8081);
socket.write('Hello, Server!');
socket.cast<List<int>>().transform(utf8.decoder).listen(print);

当我们再去追查Socket的实现代码时，又会发现，它其实是对RawSocket类的封装。所以，我们干脆来看一个例子，学习一下RawSocket怎么用：

RawSocket socket =  await RawSocket.connect("127.0.0.1", 8081);
socket.listen((event) {
    switch(event){
        case RawSocketEvent.read:
            if(socket.available() > 0){
                var buffer = socket.read();
                // TODO:
            }
            break;
        case RawSocketEvent.write:
            socket.write([96,97,98]);
            break;
        case RawSocketEvent.readClosed:
        case RawSocketEvent.closed:
            socket.close();
            break;
    }
});

整个Demo很简单，首先通过RawSocket.connect连接指定的IP和端口，然后监听连接事件，当事件为RawSocketEvent.read时，说明服务器有数据发过来，我们需要去读取，当事件为RawSocketEvent.write时，说明底层已经准备好，我们可以发送数据。

到这里，我们就找到了源码跟踪的目标，那就是RawSocket.connect方法的实现。

socket.dart

abstract interface class RawSocket implements Stream<RawSocketEvent> {
    ...
    external static Future<RawSocket> connect(host, int port,
      {sourceAddress, int sourcePort = 0, Duration? timeout});
    ...
}

学习了上一篇文章，我们已经有了一点经验，实际上这里的connect方法并不是一个本地扩展方法，很可能只是隐藏了实现，我们轻车路熟的找到sdk\lib\_internal\vm\bin\socket_patch.dart：

class RawSocket {
  @patch
  static Future<RawSocket> connect(dynamic host, int port,
      {dynamic sourceAddress, int sourcePort = 0, Duration? timeout}) {
    return _RawSocket.connect(host, port, sourceAddress, sourcePort, timeout);
  }
 
  @patch
  static Future<ConnectionTask<RawSocket>> startConnect(dynamic host, int port,
      {dynamic sourceAddress, int sourcePort = 0}) {
    return _RawSocket.startConnect(host, port, sourceAddress, sourcePort);
  }
}

可以看到，补丁内容很少，主要是调用了子类_RawSocket.connect方法：

  static Future<RawSocket> connect(dynamic host, int port,
      dynamic sourceAddress, int sourcePort, Duration? timeout) {
    return _NativeSocket.connect(host, port, sourceAddress, sourcePort, timeout)
        .then((socket) {
      if (!const bool.fromEnvironment("dart.vm.product")) {
        _SocketProfile.collectNewSocket(
            socket.nativeGetSocketId(), _tcpSocket, socket.address, port);
      }
      return _RawSocket(socket);
    });
  }

继续查看_NativeSocket中的connect实现：

  static Future<_NativeSocket> connect(dynamic host, int port,
      dynamic sourceAddress, int sourcePort, Duration? timeout) {
    return startConnect(host, port, sourceAddress, sourcePort)
        .then((ConnectionTask<_NativeSocket> task) {
      Future<_NativeSocket> socketFuture = task.socket;
      if (timeout != null) {
        socketFuture = socketFuture.timeout(timeout, onTimeout: () {
          task.cancel();
          throw createError(
              null, "Connection timed out, host: ${host}, port: ${port}");
        });
      }
      return socketFuture;
    });
  }

继续查看startConnect：

static Future<ConnectionTask<_NativeSocket>> startConnect(
      dynamic host, int port, dynamic sourceAddress, int sourcePort) {
    // ...省略部分代码
 
    return new Future.value(host).then<ConnectionTask<_NativeSocket>>((host) {
      if (host is String) {
        host = _InternetAddress.tryParse(host) ?? host;
      }
      if (host is _InternetAddress) {
        return tryConnectToResolvedAddresses(host, port, source, sourcePort,
            Stream.value(<_InternetAddress>[host]), stackTrace);
      }
      final hostname = host as String;
 
      final Stream<List<InternetAddress>> addresses =
          staggeredLookup(hostname, source);
      return tryConnectToResolvedAddresses(
          host, port, source, sourcePort, addresses, stackTrace);
    });
  }

可以看到，主要是调用了tryConnectToResolvedAddresses方法，这个方法的实现代码非常多，这里我做一些删减，只显示最关键的代码：

  static ConnectionTask<_NativeSocket> tryConnectToResolvedAddresses(
      dynamic host,
      int port,
      _InternetAddress? source,
      int sourcePort,
      Stream<List<InternetAddress>> addresses,
      StackTrace callerStackTrace) {
    ...
    Object? createConnection(InternetAddress address, _InternetAddress? source,
        _NativeSocket socket) {
      Object? connectionResult;
      if (address.type == InternetAddressType.unix) {
        if (source == null) {
          connectionResult = socket.nativeCreateUnixDomainConnect(
              address.address, _Namespace._namespace);
        } else {
          ...
          connectionResult = socket.nativeCreateUnixDomainBindConnect(
              address.address, source.address, _Namespace._namespace);
        }
      } else {
        final address_ = address as _InternetAddress;
        if (source == null && sourcePort == 0) {
          connectionResult = socket.nativeCreateConnect(
              address_._in_addr, port, address_._scope_id);
        } else {
          ...
          connectionResult = socket.nativeCreateBindConnect(address_._in_addr,
              port, source._in_addr, sourcePort, address_._scope_id);
        }
      }
      return connectionResult;
    }
 
    // Invoked either directly or via throttling Timer callback when we
    // are ready to verify that we can connect to resolved address.
    connectNext() {
      ...
      final Object? connectionResult =
          createConnection(address, source, socket);
      if (connectionResult != true) {
        // connectionResult was not a success.
        error = createConnectionError(connectionResult, address, port, socket);
        connectNext(); // Try again after failure to connect.
        return;
      }
      ...
    }
    connectNext();
    return new ConnectionTask<_NativeSocket>._(result.future, onCancel);
  }

可以看到，这个函数中又定义了几个闭包函数，我删减了一些，这里最关键的是调用createConnection这个闭包创建连接。connectNext实际上是对多个地址的遍历，它的内部就是调用createConnection建立连接的。

createConnection中，又根据地址的不同，分别调用三种不同的本地扩展方法：

• nativeCreateUnixDomainConnect
• nativeCreateConnect
• nativeCreateBindConnect

其实它们底层实现都类似，这里按照我们Demo的调用方式，应该跟踪nativeCreateConnect方法：

  @pragma("vm:external-name", "Socket_CreateConnect")
  external nativeCreateConnect(Uint8List addr, int port, int scope_id);

根据声明，我们去C++中检索Socket_CreateConnect函数：

sdk\runtime\bin\socket.cc

void FUNCTION_NAME(Socket_CreateConnect)(Dart_NativeArguments args) {
  RawAddr addr;
  SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
  Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
  int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
  SocketAddress::SetAddrPort(&addr, static_cast<intptr_t>(port));
  if (addr.addr.sa_family == AF_INET6) {
    Dart_Handle scope_id_arg = Dart_GetNativeArgument(args, 3);
    int64_t scope_id =
        DartUtils::GetInt64ValueCheckRange(scope_id_arg, 0, 65535);
    SocketAddress::SetAddrScope(&addr, scope_id);
  }
  intptr_t socket = Socket::CreateConnect(addr);
  OSError error;
  if (socket >= 0) {
    Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket,
                                   Socket::kFinalizerNormal);
    Dart_SetReturnValue(args, Dart_True());
  } else {
    Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
  }
}

这里主要是调用Socket::CreateConnect函数创建连接，但是这里的socket.cc并没有该函数的具体实现，头文件socket.h中只有声明：

  // Creates a socket which is bound and connected. The port to connect to is
  // specified as the port component of the passed RawAddr structure.
  static intptr_t CreateConnect(const RawAddr& addr);

其实Native层面的套接字是操作系统的API，不同的系统有不同的API，所以这里肯定是需要做条件编译的，不同的系统平台，其实现函数是不同的，但是总体来说，主要还是分为Windows、POSIX、Fuchsia 三大套，像Android、iOS、Linux、MacOS都是属于POSIX系列的Socket编程。这里我们先选取Android和Linux平台的实现来分析一下：

sdk\runtime\bin\socket_linux.cc

static intptr_t Create(const RawAddr& addr) {
  intptr_t fd;
  intptr_t type = SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC;
  fd = NO_RETRY_EXPECTED(socket(addr.ss.ss_family, type, 0));
  if (fd < 0) {
    return -1;
  }
  return fd;
}
 
static intptr_t Connect(intptr_t fd, const RawAddr& addr) {
  intptr_t result = TEMP_FAILURE_RETRY(
      connect(fd, &addr.addr, SocketAddress::GetAddrLength(addr)));
  if ((result == 0) || (errno == EINPROGRESS)) {
    return fd;
  }
  FDUtils::SaveErrorAndClose(fd);
  return -1;
}
 
intptr_t Socket::CreateConnect(const RawAddr& addr) {
  intptr_t fd = Create(addr);
  if (fd < 0) {
    return fd;
  }
  return Connect(fd, addr);
}

CreateConnect内部主要是调用了两个方法，Create和Connect，这里涉及的socket()和connect()函数调用，就是基本的POSIX Socket编程了，如果不清楚的，可以去了解一些C语言Socket编程相关知识。这里我们需要重点关注的是标志位SOCK_NONBLOCK，在调用socket()函数时，添加了此标志位，这就表示创建一个非阻塞的套接字。这就意味着在进行套接字相关的输入输出操作时，如果操作不能立即完成，这些操作将不会阻塞当前线程。

再看看sdk\runtime\bin\socket_android.cc

static intptr_t Create(const RawAddr& addr) {
  intptr_t fd;
  fd = NO_RETRY_EXPECTED(socket(addr.ss.ss_family, SOCK_STREAM, 0));
  if (fd < 0) {
    return -1;
  }
  if (!FDUtils::SetCloseOnExec(fd) || !FDUtils::SetNonBlocking(fd)) {
    FDUtils::SaveErrorAndClose(fd);
    return -1;
  }
  return fd;
}
 
static intptr_t Connect(intptr_t fd, const RawAddr& addr) {
  intptr_t result = TEMP_FAILURE_RETRY(
      connect(fd, &addr.addr, SocketAddress::GetAddrLength(addr)));
  if ((result == 0) || (errno == EINPROGRESS)) {
    return fd;
  }
  FDUtils::SaveErrorAndClose(fd);
  return -1;
}
 
intptr_t Socket::CreateConnect(const RawAddr& addr) {
  intptr_t fd = Create(addr);
  if (fd < 0) {
    return fd;
  }
 
  return Connect(fd, addr);
}

Android的代码大同小异，只是在调用socket()函数时没有设置SOCK_NONBLOCK标志位。由此我们就可以判断，linux实现和android的实现代码很可能不是同一个人写的。我们注意到，Android的Create方法中调用了FDUtils::SetNonBlocking()方法设置非阻塞方式。在POSIX Socket编程中，有两种方法可以创建非阻塞IO，一种是前面代码中调用socket()函数时传标志位，另一种是调用fcntl函数设置。这里的FDUtils::SetNonBlocking其实就是封装了fcntl函数的调用，使用的第二种方式。同一个人写代码，基本上风格都是统一的，不太可能一会儿一个风格。

通常，在阻塞模式下，如果一个套接字操作（例如 accept, read, write, connect 等）不能立即完成，该操作会挂起调用线程直到操作完成。例如，如果你在读取一个套接字，而没有数据可用，那么在阻塞模式下的 read 调用将会一直等待直到有数据到来。
而在非阻塞模式下，这些操作会立即返回，即使操作并未完成。如果操作因为需要等待某些条件而无法立即完成，操作将返回一个错误码（通常是 EWOULDBLOCK 或 EAGAIN），而不是挂起调用线程。

那么非阻塞IO如何读取数据呢？

非阻塞套接字通常与I/O多路复用（如 select, poll, epoll）结合使用，使单个线程能够高效地管理多个并发I/O操作。有些人喜欢把这称为异步IO，其实严格的说，非阻塞IO并不是异步IO，真正的异步IO是AIO技术。

Dart 在网络IO方面的实现，就是基于各个操作系统主流的I/O多路复用技术，Linux内核上是使用的epoll，MacOS内核上是使用的kqueue，这也是Unix内核的标准，WIndows上则是使用的IOCP技术。

至此，我们明白了，Dart是通过操作系统底层的非阻塞IO发送网络请求，理论上是不会阻塞当前线程的。当然，这只是理论，实际上，当调用epoll_wait()监听文件描述符时，依然会阻塞Dart的主线程。所以Dart VM仍然是为网络连接单独创建了工作线程执行操作，这些并不是在Dart 层的单线程模型中进行操作。

接下来，我们继续分析底层源码。那么我们的线索是什么呢？研究源码没有线索是不行的，那会成为没头苍蝇一样乱飞。

socket.listen((event) {
    switch(event){
        case RawSocketEvent.read:
            if(socket.available() > 0){
                var buffer = socket.read();
                // TODO:
            }
            break;
        case RawSocketEvent.write:
            socket.write([96,97,98]);
            break;
        case RawSocketEvent.readClosed:
        case RawSocketEvent.closed:
            socket.close();
            break;
    }
});

还记得我们前面学习的Dart RawSocket的Demo吗？这个Demo当然是有用的！当我们创建好连接后，并不是马上就可以读写数据的，需要接收到RawSocketEvent类型的相应事件，然后才会去操作读写。那么这些事件是谁发给我们的？是从哪里发出的？这就是我们要探寻的线索。

  _RawSocket(this._socket) {
     ...
    _socket.setHandlers(
        read: () => _controller.add(RawSocketEvent.read),
        write: () {
          // The write event handler is automatically disabled by the
          // event handler when it fires.
          writeEventsEnabled = false;
          _controller.add(RawSocketEvent.write);
        },
        closed: () => _controller.add(RawSocketEvent.readClosed),
        destroyed: () {
          _controller.add(RawSocketEvent.closed);
          _controller.close();
        },
        error: zone.bindBinaryCallbackGuarded((Object e, StackTrace? st) {
          _controller.addError(e, st);
          _socket.close();
        }));
  }
 
// _NativeSocket 类
  void setHandlers(
      {void Function()? read,
      void Function()? write,
      void Function(Object e, StackTrace? st)? error,
      void Function()? closed,
      void Function()? destroyed}) {
    readEventHandler = read;
    writeEventHandler = write;
    errorEventHandler = error;
    closedEventHandler = closed;
    destroyedEventHandler = destroyed;
  }

我们可以看到Dart 层_RawSocket类的构造方法，它通过调用_NativeSocket类的setHandlers方法设置了一些回调，当相应的回调被调用时，它就向Stream中发射RawSocketEvent事件。setHandlers方法的实现也很简单，就是赋值，我们先追踪一下read事件，检索一下readEventHandler被谁调用了：

  // Multiplexes socket events to the socket handlers.
  void multiplex(Object eventsObj) {
    int events = eventsObj as int;
    for (int i = firstEvent; i <= lastEvent; i++) {
      if (((events & (1 << i)) != 0)) {
        if (isClosing && i != destroyedEvent) continue;
        switch (i) {
          case readEvent:
            if (isClosedRead) continue;
            if (isListening) {
              connections++;
              if (!isClosed) {
                // If the connection is closed right after it's accepted, there's a
                // chance the close-handler is not set.
                var handler = readEventHandler;
                if (handler != null) handler();
              }
            }
            ...
            break;
          case writeEvent:
            ...
            continue;
          case errorEvent:
            ...
            break;
          case closedEvent:
            ...
            break;
          case destroyedEvent:
            ...
            continue;
        }
      }
    }
   ...
  }

看注释我们也知道，这个方法就是处理多路复用的，这里我精简了大量事件处理的代码，只留下了readEvent事件处理的逻辑。

我们继续追踪：

  void setListening({bool read = true, bool write = true}) {
    sendReadEvents = read;
    sendWriteEvents = write;
    if (read) issueReadEvent();
    if (write) issueWriteEvent();
    if (!flagsSent && !isClosing) {
      flagsSent = true;
      int flags = 1 << setEventMaskCommand;
      if (!isClosedRead) flags |= 1 << readEvent;
      if (!isClosedWrite) flags |= 1 << writeEvent;
      sendToEventHandler(flags);
    }
  }
 
void sendToEventHandler(int data) {
    int fullData = (typeFlags & typeTypeMask) | data;
    assert(!isClosing);
    connectToEventHandler();
    _EventHandler._sendData(this, eventPort!.sendPort, fullData);
  }
 
void connectToEventHandler() {
    assert(!isClosed);
    if (eventPort == null) {
      eventPort = new RawReceivePort(multiplex, 'Socket Event Handler');
    }
  }

来了来了，我们看见了什么，又见端口通信！还记得我在上一篇文章说了什么吗？在Dart中使用端口通信的目的就是为了跨线程。这里必然是有工作线程的。

不过connectToEventHandler()这里使用了RawReceivePort创建消息接收端口，一般大家都使用更高级的ReceivePort，而这个类更底层，因此很少使用，可能很多人对这个类不熟。ReceivePort直接通过listen注册一个回调监听流接收消息，而RawReceivePort则需要传一个消息处理器接收消息。这里multiplex方法就是消息处理器。

创建好了消息接收端口后，又通过_EventHandler._sendData()，将接收端口的sendPort发送了出去，这里肯定是发给了Dart VM底层。而sendToEventHandler方法又被setListening()调用，setListening()则是在前面我们见过的tryConnectToResolvedAddresses()中被调用。也就是是说，创建连接后，立刻就设置了事件监听器。

我们可以稍微关注一下这里的sendToEventHandler()被传入的参数data，显然它是一个掩码。isClosedRead和isClosedWrite默认值都是false，我们在Demo中没有主动设置它，因此，flags经过按位或操作后，最终的值应该是0001 0000 0000 0011。在sendToEventHandler()方法中，这个掩码又经过了一些操作，但是经过我的演算，最终的fullData值仍然是0001 0000 0000 0011，这个值将会发送到Dart VM底层。

接下来，我们需要重点探索一下_EventHandler._sendData方法：

  @pragma("vm:external-name", "EventHandler_SendData")
  external static void _sendData(Object? sender, SendPort sendPort, int data);

这是一个本地扩展方法，那么我们就要到C++源码中去检索EventHandler_SendData函数了：

sdk\runtime\bin\eventhandler.cc

void FUNCTION_NAME(EventHandler_SendData)(Dart_NativeArguments args) {
  Dart_Handle handle = Dart_GetNativeArgument(args, 1);
  Dart_Port dart_port;
  handle = Dart_SendPortGetId(handle, &dart_port);
  if (Dart_IsError(handle)) {
    Dart_PropagateError(handle);
    UNREACHABLE();
  }
  Dart_Handle sender = Dart_GetNativeArgument(args, 0);
  intptr_t id;
  if (Dart_IsNull(sender)) {
    id = kTimerId;
  } else {
    Socket* socket = Socket::GetSocketIdNativeField(sender);
    ASSERT(dart_port != ILLEGAL_PORT);
    socket->set_port(dart_port);
    socket->Retain();  // inc refcount before sending to the eventhandler.
    id = reinterpret_cast<intptr_t>(socket);
  }
  int64_t data = DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 2));
  event_handler->SendData(id, dart_port, data);
}

看到这个函数，里面提取转换参数的过程就不说了，主要的逻辑其实只有三处：

• 获取C++层面的Socket对象：Socket::GetSocketIdNativeField。这里的Socket对象就是前面通过调用Socket_CreateConnect函数创建的，还记得它里面有这么一行代码Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket,Socket::kFinalizerNormal)吗？显然这里的GetSocketIdNativeField和SetSocketIdNativeField是成对调用的。作用类似于Java JNI的反射，通过VM层面的C++代码去修改Dart类的成员属性。这里就是把C++的Socket对象句柄赋值给Dart的_NativeSocket类成员属性，从而达到一个关联的效果。
• 在Socket类中设置了一个Dart层的发送端口：socket->set_port(dart_port)，这也是调用_sendData方法的一个主要目的之一。这样一来，将来VM层就可以通过这个发送端口给Dart上层发消息了。
• 处理事件：event_handler->SendData(id, dart_port, data)。我们前面解析了这里的data参数，它其实是一个事件掩码，这里调用事件处理器，显然是为了处理我们传下来的掩码。

那么接下来跟踪的线索，显然就是event_handler->SendData()方法：

static EventHandler* event_handler = NULL;
static Monitor* shutdown_monitor = NULL;
 
void EventHandler::Start() {
  // Initialize global socket registry.
  ListeningSocketRegistry::Initialize();
 
  ASSERT(event_handler == NULL);
  shutdown_monitor = new Monitor();
  event_handler = new EventHandler();
  event_handler->delegate_.Start(event_handler);
 
  if (!SocketBase::Initialize()) {
    FATAL("Failed to initialize sockets");
  }
}

首先发现，event_handler是一个静态的全局变量，它在Start()方法中被初始化。在\sdk\runtime\bin\eventhandler.h头文件中有其实现：

  void SendData(intptr_t id, Dart_Port dart_port, int64_t data) {
    delegate_.SendData(id, dart_port, data);
  }

而这里的delegate_其实是EventHandler的子类EventHandlerImplementation。在不同的操作系统平台上，其实现也是不同的，这里我们就查看linux系统上的实现，sdk\runtime\bin\eventhandler_linux.cc：

void EventHandlerImplementation::SendData(intptr_t id,Dart_Port dart_port,int64_t data) {
  WakeupHandler(id, dart_port, data);
}
 
void EventHandlerImplementation::WakeupHandler(intptr_t id,Dart_Port dart_port,int64_t data) {
  InterruptMessage msg;
  msg.id = id;
  msg.dart_port = dart_port;
  msg.data = data;
  ASSERT(kInterruptMessageSize < PIPE_BUF);
  intptr_t result =
      FDUtils::WriteToBlocking(interrupt_fds_[1], &msg, kInterruptMessageSize);
  if (result != kInterruptMessageSize) {
    if (result == -1) {
      perror("Interrupt message failure:");
    }
    FATAL("Interrupt message failure. Wrote %" Pd " bytes.", result);
  }
}

从这里开始的代码，就涉及更多C语言 Linux 系统编程的知识了，不易理解，大家可以去查询一些相关资料帮助理解，主要是涉及Linux 匿名管道编程，epoll编程知识，可自行学习。后面我就主要做简单的流程概括，不作代码的详细解释了。

Linux的管道主要是作为一种跨进程通信的手段，当然也可以用于两个线程通信，这里就是用于线程间通信。

以上WakeupHandler方法的实现很容易理解，主要就是将我们前面的参数封装成一个InterruptMessage消息类，然后通过FDUtils::WriteToBlocking函数把消息写入了管道，其实就是发送了出去。

管道分为两头，一个写一个读：

int interrupt_fds_[2];

这里interrupt_fds_就是一个含有两个文件描述符的数组，interrupt_fds_[1]这头用来写，那么interrupt_fds_[0]那一端肯定就是用来读取消息的。我们只要搜索interrupt_fds_[0]就能找到接收消息的代码：

EventHandlerImplementation::EventHandlerImplementation()
    : socket_map_(&SimpleHashMap::SamePointerValue, 16) {
  intptr_t result;
  result = NO_RETRY_EXPECTED(pipe(interrupt_fds_));
  ...
  shutdown_ = false;
  static const int kEpollInitialSize = 64;
  epoll_fd_ = NO_RETRY_EXPECTED(epoll_create(kEpollInitialSize));
  ...
  struct epoll_event event;
  event.events = EPOLLIN;
  event.data.ptr = NULL;
  int status = NO_RETRY_EXPECTED(
      epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupt_fds_[0], &event));
  if (status == -1) {
    FATAL("Failed adding interrupt fd to epoll instance");
  }
  timer_fd_ = NO_RETRY_EXPECTED(timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC));
  if (timer_fd_ == -1) {
    FATAL("Failed creating timerfd file descriptor: %i", errno);
  }
  // Register the timer_fd_ with the epoll instance.
  event.events = EPOLLIN;
  event.data.fd = timer_fd_;
  status =
      NO_RETRY_EXPECTED(epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &event));
  if (status == -1) {
    FATAL("Failed adding timerfd fd(%i) to epoll instance: %i", timer_fd_,
          errno);
  }
}

我们发现，管道是在EventHandlerImplementation类的构造方法中创建的：pipe(interrupt_fds_)，以上省略部分代码。然后通过epoll_create函数创建了一个 epoll 实例，接着调用epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupt_fds_[0], &event))这行，把管道接收端添加到了epoll的监听中。那么根据Linux epoll多路复用的机制，必须使用epoll_wait函数完成消息接收，所以我们只需要在代码中搜索epoll_wait函数在哪即可。但是此处有一个地方需要注意，就是 struct epoll_event结构体的成员赋值，我们监听管道时， event.data.ptr = NULL。

void EventHandlerImplementation::Poll(uword args) {
  ThreadSignalBlocker signal_blocker(SIGPROF);
  static const intptr_t kMaxEvents = 16;
  struct epoll_event events[kMaxEvents];
  EventHandler* handler = reinterpret_cast<EventHandler*>(args);
  EventHandlerImplementation* handler_impl = &handler->delegate_;
  ASSERT(handler_impl != NULL);
  while (!handler_impl->shutdown_) {
    intptr_t result = TEMP_FAILURE_RETRY_NO_SIGNAL_BLOCKER(
        epoll_wait(handler_impl->epoll_fd_, events, kMaxEvents, -1));
    ASSERT(EAGAIN == EWOULDBLOCK);
    if (result <= 0) {
      if (errno != EWOULDBLOCK) {
        perror("Poll failed");
      }
    } else {
      handler_impl->HandleEvents(events, result);
    }
  }
  DEBUG_ASSERT(ReferenceCounted<Socket>::instances() == 0);
  handler->NotifyShutdownDone();
}

全局只有一处，就是以上Poll()方法。其实这里的核心代码也只有一行：handler_impl->HandleEvents(events, result)，我们继续跟踪

void EventHandlerImplementation::HandleEvents(struct epoll_event* events,int size) {
  bool interrupt_seen = false;
  for (int i = 0; i < size; i++) {
    if (events[i].data.ptr == NULL) {
      interrupt_seen = true;
    } else if (events[i].data.fd == timer_fd_) {
      int64_t val;
      VOID_TEMP_FAILURE_RETRY_NO_SIGNAL_BLOCKER(
          read(timer_fd_, &val, sizeof(val)));
      if (timeout_queue_.HasTimeout()) {
        DartUtils::PostNull(timeout_queue_.CurrentPort());
        timeout_queue_.RemoveCurrent();
      }
      UpdateTimerFd();
    } else {
      DescriptorInfo* di =
          reinterpret_cast<DescriptorInfo*>(events[i].data.ptr);
      const intptr_t old_mask = di->Mask();
      const intptr_t event_mask = GetPollEvents(events[i].events, di);
      if ((event_mask & (1 << kErrorEvent)) != 0) {
        di->NotifyAllDartPorts(event_mask);
        UpdateEpollInstance(old_mask, di);
      } else if (event_mask != 0) {
        Dart_Port port = di->NextNotifyDartPort(event_mask);
        ASSERT(port != 0);
        UpdateEpollInstance(old_mask, di);
        DartUtils::PostInt32(port, event_mask);
      }
    }
  }
  if (interrupt_seen) {
    HandleInterruptFd();
  }
}

这里就是处理事件的地方了。还记得我们前面说的，关于struct epoll_event结构体成员的赋值吗？显然，这里应该走interrupt_seen = true;的逻辑。中间大段代码被跳过，最终直接执行HandleInterruptFd()：

void EventHandlerImplementation::HandleInterruptFd() {
  const intptr_t MAX_MESSAGES = kInterruptMessageSize;
  InterruptMessage msg[MAX_MESSAGES];
  ssize_t bytes = TEMP_FAILURE_RETRY_NO_SIGNAL_BLOCKER(
      read(interrupt_fds_[0], msg, MAX_MESSAGES * kInterruptMessageSize));
  for (ssize_t i = 0; i < bytes / kInterruptMessageSize; i++) {
    if (msg[i].id == kTimerId) {
      timeout_queue_.UpdateTimeout(msg[i].dart_port, msg[i].data);
      UpdateTimerFd();
    } else if (msg[i].id == kShutdownId) {
      shutdown_ = true;
    } else {
      ASSERT((msg[i].data & COMMAND_MASK) != 0);
      Socket* socket = reinterpret_cast<Socket*>(msg[i].id);
      RefCntReleaseScope<Socket> rs(socket);
      if (socket->fd() == -1) {
        continue;
      }
      DescriptorInfo* di =
          GetDescriptorInfo(socket->fd(), IS_LISTENING_SOCKET(msg[i].data));
      if (IS_COMMAND(msg[i].data, kShutdownReadCommand)) {
        ASSERT(!di->IsListeningSocket());
        // Close the socket for reading.
        VOID_NO_RETRY_EXPECTED(shutdown(di->fd(), SHUT_RD));
      }
        // ......省略部分事件处理代码
        else if (IS_COMMAND(msg[i].data, kSetEventMaskCommand)) {
        // `events` can only have kInEvent/kOutEvent flags set.
        intptr_t events = msg[i].data & EVENT_MASK;
        ASSERT(0 == (events & ~(1 << kInEvent | 1 << kOutEvent)));
 
        intptr_t old_mask = di->Mask();
        di->SetPortAndMask(msg[i].dart_port, msg[i].data & EVENT_MASK);
        UpdateEpollInstance(old_mask, di);
      } else {
        UNREACHABLE();
      }
    }
  }
}

显然，此处读取出InterruptMessage消息，并做事件处理，我省略了部分其他事件处理的逻辑，直接看kSetEventMaskCommand事件的处理代码。还记得我们在Dart层生成掩码的代码吗：int flags = 1 << setEventMaskCommand，正好与此处对应了。它首先将端口和掩码设置到DescriptorInfo对象中，然后调用了UpdateEpollInstance(old_mask, di)方法，看名称也知道，此处是修改epoll的监听，让我们来看看，具体是怎么修改的：

void EventHandlerImplementation::UpdateEpollInstance(intptr_t old_mask,DescriptorInfo* di) {
  intptr_t new_mask = di->Mask();
  if ((old_mask != 0) && (new_mask == 0)) {
    RemoveFromEpollInstance(epoll_fd_, di);
  } else if ((old_mask == 0) && (new_mask != 0)) {
    AddToEpollInstance(epoll_fd_, di);
  } else if ((old_mask != 0) && (new_mask != 0) && (old_mask != new_mask)) {
    ASSERT(!di->IsListeningSocket());
    RemoveFromEpollInstance(epoll_fd_, di);
    AddToEpollInstance(epoll_fd_, di);
  }
}

显然的，new_mask和old_mask都不为0，走最后的分支，也就是说，先删除之前的epoll监听，也就是对管道的监听。然后添加了一个新的对di的监听：

static void AddToEpollInstance(intptr_t epoll_fd_, DescriptorInfo* di) {
  struct epoll_event event;
  event.events = EPOLLRDHUP | di->GetPollEvents();
  if (!di->IsListeningSocket()) {
    event.events |= EPOLLET;
  }
  event.data.ptr = di;
  int status =
      NO_RETRY_EXPECTED(epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, di->fd(), &event));
  if (status == -1) {
    di->NotifyAllDartPorts(1 << kCloseEvent);
  }
}

可见，依然是对系统APIepoll_ctl的封装，具体监听的文件描述符，其实就是DescriptorInfo对象中设置的文件描述符。那么这个传进来的DescriptorInfo对象又是哪来的呢？

      Socket* socket = reinterpret_cast<Socket*>(msg[i].id);
 
      if (socket->fd() == -1) {
        continue;
      }
      DescriptorInfo* di =
          GetDescriptorInfo(socket->fd(), IS_LISTENING_SOCKET(msg[i].data));

其实就是监听的管道消息发过来的Socket的文件描述符，也就是我们一开始创建连接打开的那个文件描述符。这一系列操作绕来绕去，其实就是干嘛呢？就是利用linux内核的epoll去监听我们最开始创建的连接。

假如此时服务器给我们的客户端发来了一条消息，那么接收消息的逻辑在哪呢？还是跟前面的管道一样，根据epoll机制，消息发过来由epoll_wait函数处理。如此一来，又回到了我们前面的Poll方法。我们再仔细看看之前跳过了一大段逻辑的HandleEvents方法：

void EventHandlerImplementation::HandleEvents(struct epoll_event* events,int size) {
  bool interrupt_seen = false;
  for (int i = 0; i < size; i++) {
    if (events[i].data.ptr == NULL) {
      ...
    } else if (events[i].data.fd == timer_fd_) {
      ...
    } else {
      DescriptorInfo* di =
          reinterpret_cast<DescriptorInfo*>(events[i].data.ptr);
      const intptr_t old_mask = di->Mask();
      const intptr_t event_mask = GetPollEvents(events[i].events, di);
      if ((event_mask & (1 << kErrorEvent)) != 0) {
        di->NotifyAllDartPorts(event_mask);
        UpdateEpollInstance(old_mask, di);
      } else if (event_mask != 0) {
        Dart_Port port = di->NextNotifyDartPort(event_mask);
        ASSERT(port != 0);
        UpdateEpollInstance(old_mask, di);
        DartUtils::PostInt32(port, event_mask);
      }
    }
  }
  if (interrupt_seen) {
    HandleInterruptFd();
  }
}

这一次，显然走else分支。如果没有错误，那么应该从DescriptorInfo中取出Dart_Port，最后应该调用DartUtils::PostInt32(port, event_mask)通过之前保存的发送端口，给Dart上层发消息。这里发送的应该就是网络IO可读的事件掩码。

看到此处，我们可以舒一口气了，整个流程基本梳理了一遍。但是有些小伙伴可能要质疑了，你前面不是说创建子线程工作，跨线程通信吗？怎么前面源码剖析的部分压根没看见线程呢？

其实前面我为了源码跟踪思路的流畅，故意忽略了一个问题，那就是Poll方法是谁调用的？我们讲到WakeupHandler方法向匿名管道发消息，然后马上就跳到Poll方法收消息，这显然是有问题的，中间缺失了一环。

这里就不卖关子了，直接回到EventHandler创建之处，来剖析一下，整个EventHandler是怎么运转的。

void EventHandler::Start() {
  ...
  event_handler = new EventHandler();
  event_handler->delegate_.Start(event_handler);
  ...
}

可以看到，这里的Start是子类实现的：

void EventHandlerImplementation::Start(EventHandler* handler) {
  int result = Thread::Start("dart:io EventHandler", &EventHandlerImplementation::Poll,
                    reinterpret_cast<uword>(handler));
  if (result != 0) {
    FATAL("Failed to start event handler thread %d", result);
  }
}

可见，EventHandler其实是在一开始就创建了一个内部子线程，这个子线程专门用来调用Poll方法执行事件处理逻辑。也就是说，Poll里面执行的方法，都是在VM的另一个子线程中，因此Dart层的主线程必须并且只能通过端口通信的方法，与底层交互。

PS： 多说一句，在我们前面的Dart VM 线程池剖析一文中提到过OSThread类，那个类就是Dart对操作系统线程的抽象，并且在不同系统平台有不同的实现文件。然而这里又冒出来一个Thread类，它也是Dart对操作系统线程的抽象，根据不同系统平台有不同的实现文件。由此我们可以看出，Dart VM源码存在一些混乱，应该也是经历了几波不同的人接手，代码不统一，存在各写各的工具类的问题。

最后我们看看，EventHandler::Start方法是哪里调用的呢？经过检索，我们发现其实是在sdk\runtime\bin\dart_embedder_api_impl.cc中：

bool InitOnce(char** error) {
  if (!bin::DartUtils::SetOriginalWorkingDirectory()) {
    bin::OSError err;
    *error = MallocFormatedString("Error determining current directory: %s\n",
                                  err.message());
    return false;
  }
  bin::TimerUtils::InitOnce();
  bin::Process::Init();
#if !defined(DART_IO_SECURE_SOCKET_DISABLED)
  bin::SSLFilter::Init();
#endif
  bin::EventHandler::Start();
  return true;
}

这里的InitOnce，则是在整个虚拟机创建时调用的，也就是C++的入口，main函数中进行调用初始化。

---

关注公众号：编程之路从0到1