class
Isolate

An isolated Dart execution context.

All Dart code runs in an isolate, and code can access classes and values only from the same isolate. Different isolates can communicate by sending values through ports (see ReceivePort, SendPort).

An Isolate object is a reference to an isolate, usually different from the current isolate. It represents, and can be used control, the other isolate.

When spawning a new isolate, the spawning isolate receives an Isolate object representing the new isolate when the spawn operation succeeds.

Isolates run code in its own event loop, and each event may run smaller tasks in a nested microtask queue.

An Isolate object allows other isolates to control the event loop of the isolate that it represents, and to inspect the isolate, for example by pausing the isolate or by getting events when the isolate has an uncaught error.

The controlPort gives access to controlling the isolate, and the pauseCapability and terminateCapability guard access to some control operations. The Isolate object provided by a spawn operation will have the control port and capabilities needed to control the isolate. New isolates objects can be created without some of these capabilities if necessary.

An Isolate object cannot be sent over a SendPort, but the control port and capabilities can be sent, and can be used to create a new functioning Isolate object in the receiving port's isolate.

Constants

int IMMEDIATE = 0
const
Argument to ping and kill: Ask for immediate action.
int BEFORE_NEXT_EVENT = 1
const
Argument to ping and kill: Ask for action before the next event.

Static Properties

Isolate current
read-only
Return the current [Isolate].

Static Methods

spawn(void entryPoint(message), message, {bool paused: false, bool errorsAreFatal, SendPort onExit, SendPort onError}) → Future<Isolate>
Creates and spawns an isolate that shares the same code as the current isolate.
spawnUri(Uri uri, List<String> args, message, {bool paused: false, bool checked, Uri packageRoot, bool errorsAreFatal, SendPort onExit, SendPort onError}) → Future<Isolate>
Creates and spawns an isolate that runs the code from the library with the specified URI.

Properties

SendPort controlPort
read-only
Control port used to send control messages to the isolate.
Capability pauseCapability
read-only
Capability granting the ability to pause the isolate.
Capability terminateCapability
read-only
Capability granting the ability to terminate the isolate.
Stream errors
read-only
Returns a broadcast stream of uncaught errors from the isolate.

Constructors

Isolate(SendPort controlPort, {Capability pauseCapability, Capability terminateCapability})
Create a new Isolate object with a restricted set of capabilities.

Methods

pause([Capability resumeCapability]) → Capability
Requests the isolate to pause.
resume(Capability resumeCapability) → void
Resumes a paused isolate.
addOnExitListener(SendPort responsePort, {Object response}) → void
Asks the isolate to send response on responsePort when it terminates.
removeOnExitListener(SendPort responsePort) → void
Stop listening on exit messages from the isolate.
setErrorsFatal(bool errorsAreFatal) → void
Set whether uncaught errors will terminate the isolate.
kill({int priority: BEFORE_NEXT_EVENT}) → void
Requests the isolate to shut down.
ping(SendPort responsePort, {Object response, int priority: IMMEDIATE}) → void
Request that the isolate send response on the responsePort.
addErrorListener(SendPort port) → void
Requests that uncaught errors of the isolate are sent back to port.
removeErrorListener(SendPort port) → void
Stop listening for uncaught errors through port.