Skapa och hantera arbetare

Flash Player 11.4 och senare, Adobe AIR 13.4 och senare för datorplattformar

Det första steget när du vill använda en arbetare för samtidighet är att skapa en bakgrundsarbetare. Du använder två typer av objekt när du skapar en arbetare. Den första som du skapar är Worker-instansen. Den andra är ett WorkerDomain-objekt, som skapar arbetaren och administrerar hur Worker-objekten körs i ett program.

När miljön läses in skapas automatiskt WorkerDomain-objektet. I miljön skapas dessutom automatiskt en arbetare för huvud-swf-filen för programmet. Den första arbetaren kallas den primitiva arbetaren .

Eftersom det bara finns ett WorkerDomain-objekt för ett program får du åtkomst till WorkerDomain-instansen via den statiska WorkerDomain.current -egenskapen.

Du har när som helst åtkomst till den aktuella Worker-instansen (arbetaren i vilken den aktuella koden körs) via den statiska Worker.current -egenskapen.

Skapa ett Worker-objekt från en swf-fil

Precis som huvud-swf-filen körs i den primitiva arbetaren, kör bakgrundsarbetaren kod från en enskild swf-fil. Om du vill använda en bakgrundsarbetare måste du skapa och kompilera koden som en swf-fil. Om du vill skapa bakgrundsarbetaren måste den överordnade arbetaren ha åtkomst till swf-filens byte som ett ByteArray-objekt. Du skickar denna ByteArray till WorkerDomain-objektets createWorker() -metod för att de facto skapa arbetaren.

Det finns tre sätt att erhålla bakgrundsarbetarens swf-fil som ett ByteArray-objekt:

Bädda in arbetarens swf-fil

Använd metataggen [Embed] för att bädda in arbetarens swf-fil i huvud-swf-filen som en ByteArray: 

[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(); 
    var bgWorker:Worker = WorkerDomain.current.createWorker(workerBytes); 
     
    // ... set up worker communication and start the worker 
}

Arbetarens swf-fil kompileras in i huvud-swf-filen som en ByteArray-underklass med namnet BgWorker_ByteClass. Genom att skapa en instans av klassen får du en ByteArray ifylld med byte från arbetarens swf-fil.

Läsa in en externa swf-fil för arbetaren

Använd ett URLLoader-objekt för att läsa in en extern swf-fil för arbetaren. Swf-filen måste komma från samma säkerhetsdomän, till exempel som en swf-fil som läses in från samma internetdomän som huvud-swf-filen, eller ingå i ett AIR-programpaket. 

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); 
     
    // ... set up worker communication and start the worker 
}

När inläsningen av swf-filen med URLLoader är klar är swf-filens byte tillgängliga i URLLoader-objektets data -egenskap ( event.target.data i detta exempel).

Använda huvud-swf-filen som swf-fil för arbetaren

Du kan använda en enskild swf-fil som både huvud-swf-fil och som swf-fil för arbetaren. Använd huvudvisningsklassens loaderInfo.bytes -egenskap för att få åtkomst till swf-filens byte. 

// 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 or the background worker 
    if (Worker.current.isPrimordial) 
    { 
        // create a background worker 
        var bgWorker:Worker = WorkerDomain.current.createWorker(swfBytes); 
         
        // ... set up worker communication and start the worker 
    } 
    else // entry point for the background worker 
    { 
        // set up communication between workers using getSharedProperty() 
        // ... (not shown) 
         
        // start the background work 
    } 
}

Om du använder denna teknik ska du använda en if -sats för att dela upp koden för swf-filen i huvudklassens konstruktor eller i den metod som den anropar. För att kunna bestämma om koden körs i huvudarbetaren eller i bakgrundsarbetaren ska du kontrollera det aktuella Worker-objektets isPrimordial -egenskap, se exemplet nedan.

Starta körning av en arbetare

När du har skapat en arbetare startar du körningen av den genom att anropa Worker-objektets start() -metod. Åtgärden start() startar inte omedelbart. Om du vill veta när arbetaren körs ska du registrera en avlyssnare för Worker-objektets workerState -händelse. Denna händelse skickas när Worker-objektet ändrar lägen under livscykeln, till exempel när kodkörningen inleds. I händelsehanteraren workerState kontroller du att Worker-objektets state -egenskap är WorkerState.RUNNING . Du gör det när arbetaren körs och när huvudklassens konstruktor har körts. I följande kod visas ett exempel på registrering för workerState -händelsen och anropet av start() -metoden: 

// 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(); 
private function workerStateHandler(event:Event):void 
{ 
    if (bgWorker.state == WorkerState.RUNNING) 
    { 
        // The worker is running. 
        // Send it a message or wait for a response. 
    } 
}

Administrera körning av arbetare

Med WorkerDomain-klassens listWorkers() -metod kan du när som helst komma åt den uppsättning arbetare som körs i programmet. Den här metoden returnerar den uppsättning arbetare vars state -egenskap är WorkerState.RUNNING , inklusive den primitiva arbetaren. Den är inte inkluderad om arbetaren inte har startats eller om körningen redan har stoppats.

Om du inte längre behöver en arbetare ska du anropa Worker-objektets terminate() -metod för att stänga arbetaren och frisläppa dess minne och andra systemresurser.