Question

Since Flash doesn’t support multithread how do you that in actionscript 3 ?

Answer 1

The short answer is – by adding an event listener to do it asynchronously.

The long answer is that it’s quite simple – if you’ve done it once, you’ve done it a million times:

var site_loader:Loader;
var your_text_field:TextField;

init();
start_load();

function init():void
{
    site_loader = new Loader();
    this.addChild(site_loader);

    your_text_field = new TextField();
    this.addChild(your_text_field);
}

function start_load():void
{
    site_loader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, update_progress_text);
    site_loader.addEventListener(Event.COMPLETE, start_site);
    site_loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, load_error);

    var url_path:String = "path/to/content.swf";
    var url_request:URLRequest = new URLRequest(url_path);  

    site_loader.load(url_request);
}

function update_progress_text(event:ProgressEvent):void
{
    var site_loader_progress:int = 100 * event.bytesLoaded / event.bytesTotal;
    your_text_field.text = site_loader_progress + " %";
}

function start_site(event:Event):void
{
    site_loader.contentLoaderInfo.removeEventListener(ProgressEvent.PROGRESS, update_progress_text);
    site_loader.removeEventListener(Event.COMPLETE, start_site);
    site_loader.removeEventListener(IOErrorEvent.IO_ERROR, load_error);
}

Basically the ActionScript Virtual Machine runs in a ‘Dispatch Events, Process Events, Render Graphics’ loop; each frame, events are given a timeslice, and each event is ‘essentially’ run as a thread (would be) in a uniprocessor system.

While it’s true that ActionScript isn’t multi-threaded, it does rely on a very sexy event-driven architecture that in many cases is a better alternative to threads (check out this paper here: http://www.stanford.edu/class/cs240/readings/threads-bad-usenix96.pdf).

That being said, hopefully future versions of the AVM will have explicit support for multiple threads, if only to better advantage near-ubiquitous multi-processor systems.