Skip to content

spawn ​

spawn executa uma tarefa async em paralelo com quem a chamou e devolve um JoinHandle<T> para ela.

Assinaturaspawn<T>(task: () => Promise<T>): JoinHandle<T>

JoinHandle<T>.join(): Promise<T> resolve para o resultado da tarefa, e JoinHandle<T>.abort(): void cancela cooperativamente a tarefa através do mesmo mecanismo de cancel. .join() consome o handle, consumindo o handle, então dar join duas vezes no mesmo handle, ou chamar .abort() depois de .join(), é rejeitado na compilação (E3033); .abort() em si não consome o handle, então pode ser chamado quantas vezes for antes de .join(). Um erro lançado dentro de uma tarefa criada por spawn rejeita a Promise<T> que join() devolve, exatamente como qualquer outra função assíncrona. Assim como Promise<T>, JoinHandle<T> é um tipo nativo e nunca precisa ser importado.

await spawn(...) diretamente, e await spawn(...).join() encadeado na mesma expressão, são ambos rejeitados na compilação (E3031): os dois descartam a única forma de guardar a tarefa e fazer outro trabalho enquanto ela roda em segundo plano. Um JoinHandle<T> descartado, spawn(...); como statement solto, sem guardar o retorno, é rejeitado da mesma forma que uma Promise<T> não usada, já que o resultado ou a rejeição da tarefa nunca poderiam ser observados.

Cada chamada a resolve de tyrus:net abaixo é uma ida e volta de rede de verdade, que pode demorar. Disparar as duas buscas com spawn deixa a segunda começar antes da primeira responder, em vez de esperar a vez, veja a página do Playground em Tooling para entender por que este exemplo não roda lá:

tyrus
import { NetError, resolve } from "tyrus:net";
import { spawn } from "tyrus:task";

async function lookup(host: string): Promise<string[]> {
    try {
        const addresses: string[] = await resolve(host, 2_000);
        return addresses;
    } catch (error: NetError) {
        return [];
    }
}

async function main(): Promise<void> {
    // Two independent, real network round trips, each one could take
    // hundreds of milliseconds. Spawning both means the second lookup starts
    // before the first one has replied, instead of waiting its turn.
    const first = spawn(async (): Promise<string[]> => {
        const addresses: string[] = await lookup("example.com");
        return addresses;
    });
    const second = spawn(async (): Promise<string[]> => {
        const addresses: string[] = await lookup("localhost");
        return addresses;
    });

    const exampleAddresses: string[] = await first.join();
    const localAddresses: string[] = await second.join();

    print(exampleAddresses.length > 0);
    print(localAddresses.length > 0);
}