Very simple version of Isolates.

tests/standalone/io/http_basic_test.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // VMOptions=
 // VMOptions=--short_socket_read
 // VMOptions=--short_socket_write
 // VMOptions=--short_socket_read --short_socket_write
 
 import "package:expect/expect.dart";
 import "dart:isolate";
 import "dart:io";
 
 class TestServerMain {
   TestServerMain()
       : _statusPort = new ReceivePort(),
-        _serverPort = null {
-    _serverPort = spawnFunction(startTestServer);
-  }
+        _serverPort = null;
 
   void setServerStartedHandler(void startedCallback(int port)) {
     _startedCallback = startedCallback;
   }
 
-  void start() {
+  void start([bool chunkedEncoding = false]) {
+    ReceivePort receivePort = new ReceivePort();
+    var remote = Isolate.spawn(startTestServer, receivePort.sendPort);
+    receivePort.first.then((port) {
+      _serverPort = port;
+
+      if (chunkedEncoding) {
+        // Send chunked encoding message to the server.
+        port.send(
+            [new TestServerCommand.chunkedEncoding(), _statusPort.sendPort]);
+      }
+
+      // Send server start message to the server.
+      var command = new TestServerCommand.start();
+      port.send([command, _statusPort.sendPort]);
+    });
+
     // Handle status messages from the server.
-    _statusPort.receive((var status, SendPort replyTo) {
+    _statusPort.listen((var status) {
       if (status.isStarted) {
         _startedCallback(status.port);
       }
     });
 
-    // Send server start message to the server.
-    var command = new TestServerCommand.start();
-    _serverPort.send(command, _statusPort.toSendPort());
   }
 
   void close() {
     // Send server stop message to the server.
-    _serverPort.send(new TestServerCommand.stop(), _statusPort.toSendPort());
+    _serverPort.send([new TestServerCommand.stop(), _statusPort.sendPort]);
     _statusPort.close();
   }
 
-  void chunkedEncoding() {
-    // Send chunked encoding message to the server.
-    _serverPort.send(
-        new TestServerCommand.chunkedEncoding(), _statusPort.toSendPort());
-  }
-
   ReceivePort _statusPort;  // Port for receiving messages from the server.
   SendPort _serverPort;  // Port for sending messages to the server.
   var _startedCallback;
 }
 
 
 class TestServerCommand {
   static const START = 0;
   static const STOP = 1;
   static const CHUNKED_ENCODING = 2;
@@ skipping 23 matching lines @@
   bool get isStopped => _state == STOPPED;
   bool get isError => _state == ERROR;
 
   int get port => _port;
 
   int _state;
   int _port;
 }
 
 
-void startTestServer() {
+void startTestServer(SendPort replyTo) {
   var server = new TestServer();
   server.init();
-  port.receive(server.dispatch);
+  replyTo.send(server.dispatchSendPort);
 }
 
 
 class TestServer {
   // Echo the request content back to the response.
   void _echoHandler(HttpRequest request) {
     var response = request.response;
     Expect.equals("POST", request.method);
     response.contentLength = request.contentLength;
     request.pipe(response);
@@ skipping 37 matching lines @@
     response.close();
   }
 
   void init() {
     // Setup request handlers.
     _requestHandlers = new Map();
     _requestHandlers["/echo"] = _echoHandler;
     _requestHandlers["/0123456789"] = _zeroToTenHandler;
     _requestHandlers["/reasonformoving"] = _reasonForMovingHandler;
     _requestHandlers["/host"] = _hostHandler;
+    _dispatchPort = new ReceivePort();
+    _dispatchPort.listen(dispatch);
   }
 
-  void dispatch(var message, SendPort replyTo) {
-    if (message.isStart) {
+  SendPort get dispatchSendPort => _dispatchPort.sendPort;
+
+  void dispatch(var message) {
+    TestServerCommand command = message[0];
+    SendPort replyTo = message[1];
+    if (command.isStart) {
       try {
         HttpServer.bind("127.0.0.1", 0).then((server) {
           _server = server;
           _server.listen(_requestReceivedHandler);
           replyTo.send(new TestServerStatus.started(_server.port), null);
         });
       } catch (e) {
         replyTo.send(new TestServerStatus.error(), null);
       }
-    } else if (message.isStop) {
+    } else if (command.isStop) {
       _server.close();
+      _dispatchPort.close();
       port.close();
       replyTo.send(new TestServerStatus.stopped(), null);
-    } else if (message.isChunkedEncoding) {
+    } else if (command.isChunkedEncoding) {
       _chunkedEncoding = true;
     }
   }
 
   void _requestReceivedHandler(HttpRequest request) {
     var requestHandler =_requestHandlers[request.uri.path];
     if (requestHandler != null) {
       requestHandler(request);
     } else {
       _notFoundHandler(request);
     }
   }
 
   HttpServer _server;  // HTTP server instance.
+  ReceivePort _dispatchPort;
   Map _requestHandlers;
   bool _chunkedEncoding = false;
 }
 
 void testStartStop() {
   TestServerMain testServerMain = new TestServerMain();
   testServerMain.setServerStartedHandler((int port) {
     testServerMain.close();
   });
   testServerMain.start();
@@ skipping 56 matching lines @@
                   testServerMain.close();
                 }
               });
           });
     }
 
     sendRequest();
   }
 
   testServerMain.setServerStartedHandler(runTest);
-  if (chunkedEncoding) {
-    testServerMain.chunkedEncoding();
-  }
-  testServerMain.start();
+  testServerMain.start(chunkedEncoding);
 }
 
 void test404() {
   TestServerMain testServerMain = new TestServerMain();
   testServerMain.setServerStartedHandler((int port) {
     HttpClient httpClient = new HttpClient();
     httpClient.get("127.0.0.1", port, "/thisisnotfound")
         .then((request) => request.close())
         .then((response) {
           Expect.equals(HttpStatus.NOT_FOUND, response.statusCode);
@@ skipping 35 matching lines @@
 }
 
 void main() {
   testStartStop();
   testGET();
   testPOST(true);
   testPOST(false);
   test404();
   testReasonPhrase();
 }