MessageChannel  - AS3

Indicates whether the MessageChannel has one or more messages from the sending worker in its internal message queue.

Indicates the current state of the MessageChannel object (open, closing, or closed). The possible values for this property are defined as constants in the MessageChannelState class.

Related API Elements

Registers an event listener object with an EventDispatcher object so that the listener receives notification of an event. You can register event listeners on all nodes in the display list for a specific type of event, phase, and priority.

After you successfully register an event listener, you cannot change its priority through additional calls to addEventListener(). To change a listener's priority, you must first call removeListener(). Then you can register the listener again with the new priority level.

Keep in mind that after the listener is registered, subsequent calls to addEventListener() with a different type or useCapture value result in the creation of a separate listener registration. For example, if you first register a listener with useCapture set to true, it listens only during the capture phase. If you call addEventListener() again using the same listener object, but with useCapture set to false, you have two separate listeners: one that listens during the capture phase and another that listens during the target and bubbling phases.

You cannot register an event listener for only the target phase or the bubbling phase. Those phases are coupled during registration because bubbling applies only to the ancestors of the target node.

If you no longer need an event listener, remove it by calling removeEventListener(), or memory problems could result. Event listeners are not automatically removed from memory because the garbage collector does not remove the listener as long as the dispatching object exists (unless the useWeakReference parameter is set to true).

Copying an EventDispatcher instance does not copy the event listeners attached to it. (If your newly created node needs an event listener, you must attach the listener after creating the node.) However, if you move an EventDispatcher instance, the event listeners attached to it move along with it.

If the event listener is being registered on a node while an event is being processed on this node, the event listener is not triggered during the current phase but can be triggered during a later phase in the event flow, such as the bubbling phase.

If an event listener is removed from a node while an event is being processed on the node, it is still triggered by the current actions. After it is removed, the event listener is never invoked again (unless registered again for future processing).

Parameters

function(evt:Event):void

Instructs the current MessageChannel to close once all messages have been received.

Once you call this method, you can no longer call the send() method to add messages to the queue. The send() call will fail and return false.

You can also only call the receive() method to receive messages that are already waiting in the queue. If the queue is empty, the receive() call will return null.

Retrieves a single message object from the queue of messages sent through this message channel.

Each time the sending worker's code calls the MessageChannel object's send() method, a single object is added to the message channel's internal message queue. These objects stack up in the queue until they are removed one at a time by the receiving worker calling the receive() method. The message objects are received in the order they are sent.

To check if the queue contains a message object to receive, use the messageAvailable property.

In the standard case, the object passed into send() is serialized in AMF3 format. When it is removed from the queue by the receive() call, it is deserialized into an ActionScript object (a copy of the original object) in the receiving worker and the worker receives a reference to that copy. Certain types of objects are shared between workers rather than copied. In that case the object that the receiving worker gets is a reference to the shared object itself rather than a new copy of the object. For more information about this case see the send() method description.

The method's behavior changes if the message queue is empty and you pass true for the blockUntilReceived parameter. In that case the worker pauses its execution thread at the receive() call and does not execute more code. Once the sending worker calls send(), the receive() call completes by receiving the message. The worker then resumes code execution at the next line of code following the receive call.

Parameters

Related API Elements

Removes a listener from the EventDispatcher object. If there is no matching listener registered with the EventDispatcher object, a call to this method has no effect.

Parameters

Sends an object from the sending worker, adding it to the message queue for the receiving worker.

The object passed to the arg parameter can be almost any object. Other than the exceptions noted below, any object that is passed to the arg parameter is not passed by reference. Any changes made to the object in one worker after send() is called are not carried over to the other worker. The object is copied by serializing it to AMF3 format and deserializing it into a new object in the receiving worker when receive() is called. For this reason, any object that can't be serialized in AMF3 format, including display objects, can't be passed to the arg parameter. In order for a custom class to be passed properly, the class definition must be registered using the flash.net.registerClassAlias() function or [RemoteClass] metadata. With either technique the same alias must be used for both worker's versions of the class.

There are five types of objects that are an exception to the rule that objects aren't shared between workers:

• Worker
• MessageChannel
• shareable ByteArray (a ByteArray object with its shareable property set to true
• Mutex
• Condition

If you pass an instance of these objects to the arg parameter, each worker has a reference to the same underlying object. Changes made to an instance in one worker are immediately available in other workers. In addition, if you pass the same instance of these objects more than once using send(), the runtime doesn't create a new copy of the object in the receiving worker. Instead, the same reference is re-used, reducing system memory use.

By default, this method adds the object to the queue and immediately returns, continuing execution with the next line of code. If you want to prevent the queue from growing beyond a certain size, you can use the queueLimit parameter to specify the maximum number of items to allow in the queue. If at the time you call send() the number of items in the queue is greater than the limit you specify, the worker pauses the execution thread at the send() call. Once the receiving worker calls receive() enough times that the queue size is less than the specified queue limit, the send() call completes. The worker then continues execution at the next line of code.

Parameters

Related API Elements

Returns the string representation of the specified object.

Note: Methods of the Object class are dynamically created on Object's prototype. To redefine this method in a subclass of Object, do not use the override keyword. For example, a subclass of Object implements function toString():String instead of using an override of the base class.

Dispatched each time the sending worker calls this MessageChannel object's send() method, indicating that a new message object is available in the MessageChannel instance's queue.

This event has the following properties:

Dispatched when the value of the message channel's state property changes.

This event has the following properties: