Concurrent Programming with ActionScript workers

Concurrent programming with ActionScript workers
Paul Robertson | Adobe Developer Relations | @probertson |
http://probertson.com/

© 2012 Adobe Systems Incorporated. All Rights Reserved. Adobe Confidential.

Gratuitous promotion

© 2012 Adobe Systems Incorporated. All Rights Reserved. Adobe Confidential. 2


How can I know what features were added to the Flash runtime
recently?



How can I know what features were added to the Flash runtime
recently?
http://adobe.ly/O2SRKF


Why concurrent programming?


“My UI keeps
freezing!”



“I want to run
code in the
“My UI keeps background”
freezing!”



“I want to run
code in the
“My UI keeps background”
freezing!”


“Give me
multithreaded
ActionScript…
” “…or give me
death!”



Flash Runtime’s execution model

 Single threaded
 All* code runs in a single line of execution
 This includes your code (event handlers) and runtime’s rendering code



Flash Runtime’s execution model

 Frame model
 Code execution is scheduled into time units a.k.a. “frames”
 Length based on frame rate
 Tries to execute all code in one thread in a frame’s worth of time



For example…



For example…

Enter frame
private function onEnterFrame(event:Event):void



For example…

Enter frame
Mouse event
private function onMouseOver(event:MouseEvent):void



For example…

Enter frame
Mouse event
Load complete event
private function onDataLoad(event:Event):void



For example…

Enter frame
Mouse event
Load complete event
Mouse event
private function onClick(event:MouseEvent):void



For example…

Enter frame
Mouse event
Load complete event
Mouse event
...



For example…

Enter frame
Mouse event
Load complete event
Mouse event
...
Rendering
<native player code>



33 ms later…



33 ms later…

Enter frame



Now suppose…

Enter frame
Mouse event
Load complete event
Mouse event
...
Rendering



Now suppose…
Enter frame


Mouse event


Load complete event
{
var myXML:XML = _loader.data;
for each (var dataPoint:XML in myXML.dataPoint)
{
// parse thousands of XML nodes and create objects
}
}
Mouse event


...

Rendering




> 33 ms later…


What are Workers?


What are workers?

A way to do concurrent programming safely* in ActionScript


How do they work?


How do they work?

Two important architectural needs


How do they work?


 Isolate code without language changes


How do they work?


 Avoid having to rewrite the entire Flash runtime


How do they work?

Solution

 1 SWF = 1 thread

 Separate instances of AVM

 Code isolated in SWF


How do they work?

Conceptually, it’s like this…


How do they work?

Except like this


What are Workers (redux)?



A separate AVM instance

ActionScript object
 Represents a container in which a SWF file executes
 Yes, that includes non-concurrent apps too



WorkerDomain



WorkerDomain
“Primordial” Worker



WorkerDomain
public class App extends Sprite
{
// ...
}



WorkerDomain
{
WorkerDomain.current.createWorker();
}



WorkerDomain
{
}

“background” Worker
public class BGWorker extends Sprite
{
// ...
}



WorkerDomain
{
}

“background” Worker
{
// ...
}


Caveats (part 1)


Caveats (part 1)

Desktop only – not available in mobile AIR

(for now)


How do I use a Worker? (in code please)


How do I use a Worker?

Step 1. Create the background worker SWF

{
// ...
}



Step 2. Get the bytes of the SWF
[Embed]
[Embed(source="../swfs/BgWorker.swf", mimeType="application/octet-stream")]
private static var BgWorker_ByteClass:Class;

private function createWorker():void
{
var workerBytes:ByteArray = new BgWorker_ByteClass();
}

Load
var workerLoader:URLLoader = new URLLoader();
workerLoader.dataFormat = URLLoaderDataFormat.BINARY;
workerLoader.addEventListener(Event.COMPLETE, loadComplete);
workerLoader.load(new URLRequest("BgWorker.swf"));

private function loadComplete(event:Event):void
{
var workerBytes:ByteArray = event.target.data as ByteArray;
}



Step 3. Create the Worker from the WorkerDomain


private var bgWorker:Worker;

{
bgWorker = WorkerDomain.current.createWorker(workerBytes);
}



Step 4. Register for the workerState event and start the worker


private var bgWorker:Worker;

{

bgWorker.addEventListener(Event.WORKER_STATE, workerStateHandler);
bgWorker.start()
}

private function workerStateHandler(event:Event):void
{
if (bgWorker.state == WorkerState.RUNNING)
{
// The worker is running -- send it a message or wait
}
}


Worker communication



Two new communication mechanisms

 Worker shared properties

 MessageChannel



Two new communication mechanisms

 Worker shared properties

 MessageChannel

“Classic” techniques
 Local shared objects

 Write to/read from files

 Server communication

 SQLite database



Worker shared properties
 “dictionary” of properties stored in a worker
 String keys and * values
 Available for reading and writing from within and outside the worker



 “dictionary” of properties stored in a worker
 String keys and * values
 Available for reading and writing from within and outside the worker
Setting shared property (e.g. in parent worker):
bgWorker.setSharedProperty("propertyName", someObject);

Reading shared property (e.g. in background worker):
var receivedProperty:Object;
receivedProperty = Worker.current.getSharedProperty("propertyName");



 Available even before worker.start() is called

Parent worker:
{
bgWorker.setSharedProperty("propertyName", someObject);
bgWorker.addEventListener(Event.WORKER_STATE, workerStateHandler);
bgWorker.start()
}

Background worker:
{
public function BGWorker()
{
var receivedProperty:Object;
receivedProperty = Worker.current.getSharedProperty("propertyName");
}
}



MessageChannel
 One-way data-passing channel
 One worker is the “sender,” another is the “receiver”
 When a message is sent, MessageChannel dispatches an event



Step 1. Sending worker creates the MessageChannel

Code in the sending worker:
var sendChannel:MessageChannel;
sendChannel = Worker.current.createMessageChannel(receivingWorker);



Step 2. Sending worker passes the MessageChannel to the receiver


receivingWorker.setSharedProperty("incomingChannel", sendChannel);



Step 3. Receiving worker gets the MessageChannel object

Code in the receiving worker:
var incomingChannel:MessageChannel;
incomingChannel = Worker.current.getSharedProperty("incomingChannel");



Step 4. Receiving worker listens for the channelMessage event


incomingChannel.addEventListener(Event.CHANNEL_MESSAGE, handleIncomingMessage);



Step 5. Sending worker calls the MessageChannel’s send() method


receivingWorker.setSharedProperty("incomingChannel", sendChannel);

// ...

sendChannel.send("This is a message");



Step 6. Receiving worker handles the channelMessage event


incomingChannel.addEventListener(Event.CHANNEL_MESSAGE, handleIncomingMessage);

private function handleIncomingMessage(event:Event):void
{
var message:String = incomingChannel.receive() as String;
}



Object passing rules




Objects passed to setSharedProperty() or MessageChannel.send()
are…




are…
…Serialized in AMF format by sending worker




are…
…Serialized in AMF format by sending worker
…Deserialized by receiving worker




Side effects of using AMF




Side effects of using AMF:
 Object in receiver is a copy, not a reference




Side effects of using AMF:
 Objects that can’t be serialized in AMF can’t be passed




Two exceptions:
 Worker

 MessageChannel


Caveats (part 2)


Caveats (part 2)

Code execution order is no longer guaranteed (across workers)

e.g. setting a breakpoint makes code nondeterministic


Caveats (part 2)

Performance impact

“Adobe recommends that you do not use more than
one or two background workers in a typical scenario.”


“Crystal Ball”


“Crystal Ball”

Shareable ByteArray

 Avoid AMF overhead
 Especially useful when data is binary by nature (e.g. BitmapData)


“Crystal Ball”

Mutex

 “Mutually exclusive” access to shared resource
lock()
tryLock()
unlock()


“Crystal Ball”

Mobile AIR


“Crystal Ball”

Language features

Warning: totally made up pseudocode:
public class MyClass
{
public function doSomething():void
{
// do some stuff in the main thread

backgroundThread
{
// do something in the background
// using variables/methods that are in scope
}

// do more in the main thread
}
}


Thank you and Q&A


Concurrent Programming with ActionScript workers

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (14)

Similar to Concurrent Programming with ActionScript workers

Similar to Concurrent Programming with ActionScript workers (20)

Recently uploaded

Recently uploaded (20)

Concurrent Programming with ActionScript workers

Editor's Notes