The WorkerDomain instance in which the code is currently running. This is the only WorkerDomain in the application.

Indicates whether the current runtime context supports the WorkerDomain and Worker objects for concurrent code execution.

If concurrency is available, this property's value is true.

Creates a new Worker instance from the bytes of a swf.

Each worker is created from and executes as an isolated swf application. To create a Worker instance, you obtain the bytes of the SWF file as a ByteArray instance and pass it to this method. There are three common ways to access the bytes of a swf for this purpose:

• Use the [Embed] metatag to embed the .swf file in the application as a ByteArray:

      // Embed the SWF file
      [Embed(source="../swfs/BgWorker.swf", mimeType="application/octet-stream")]
      private static var BgWorker_ByteClass:Class;
      
      private function createWorker():void
      {
        // create the background worker
        var workerBytes:ByteArray = new BgWorker_ByteClass();
        var bgWorker:Worker = WorkerDomain.current.createWorker(workerBytes);
        
        // listen for worker state changes to know when the worker is running
        bgWorker.addEventListener(Event.WORKER_STATE, workerStateHandler);
        
        // set up communication between workers using 
        // setSharedProperty(), createMessageChannel(), etc.
        // ... (not shown)
        
        bgWorker.start();
      }

• Load an external SWF file using a URLLoader:

      // load the SWF file
      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
      {
        // create the background worker
        var workerBytes:ByteArray = event.target.data as ByteArray;
        var bgWorker:Worker = WorkerDomain.current.createWorker(workerBytes);
        
        // listen for worker state changes to know when the worker is running
        bgWorker.addEventListener(Event.WORKER_STATE, workerStateHandler);
        
        // set up communication between workers using 
        // setSharedProperty(), createMessageChannel(), etc.
        // ... (not shown)
        
        bgWorker.start();
      }

• Use a single swf as both the primordial worker and the background worker:

      // The primordial worker's main class constructor
      public function PrimordialWorkerClass()
      {
        init();
      }
      
      private function init():void
      {
        var swfBytes:ByteArray = this.loaderInfo.bytes;
        
        // Check to see if this is the primordial worker
        if (Worker.current.isPrimordial)    
        {
          // create a background worker
          var bgWorker:Worker = WorkerDomain.current.createWorker(swfBytes);
          
          // listen for worker state changes to know when the worker is running
          bgWorker.addEventListener(Event.WORKER_STATE, workerStateHandler);
          
          // set up communication between workers using 
          // setSharedProperty(), createMessageChannel(), etc.
          // ... (not shown)
          
          bgWorker.start();
        }
        else // entry point for the background worker
        {
          // set up communication between workers using getSharedProperty()
          // ... (not shown)
          
          // start the background work
        }

Creating a Worker object using createWorker() does not start execution of the worker. To start a worker's code execution, call the Worker object's start() method.

Workers are useful because they decrease the chances of the frame rate dropping due to the main rendering thread being blocked by other code. However, workers require additional system memory and CPU use, which can be costly to overall application performance. Because each worker uses its own instance of the runtime virtual machine, even the overhead of a trivial worker can be large. When using workers, test your code across all your target platforms to ensure that the demands on the system are not too large. Adobe recommends that you do not use more than one or two background workers in a typical scenario.

Provides access to the set of workers in the WorkerDomain that are currently running (the Worker instance's state property is WorkerState.RUNNING).