Controlar processos com o Apex que permite a execução em fila

• Quando usar a interface Que permite a execução em fila.
• As diferenças entre os métodos futuro e que permite a execução em fila.
• A sintaxe do Apex que permite a execução em fila.
• Melhores práticas para o método que permite a execução em fila.

Nota

O desafio prático para esse emblema está traduzido para japonês, espanhol (América Latina) e português (Brasil). Para definir o idioma do seu Trailhead Playground, siga essas instruções. A tradução pode estar desatualizada. Se você não conseguir passar no desafio usando as instruções traduzidas, defina o idioma para inglês e a localidade para Estados Unidos. Em seguida, tente novamente.

Consulte o emblema Trailhead no seu idioma para saber mais sobre como aproveitar a experiência de Trailhead em outros idiomas.

• Tipos não primitivos: Sua classe Que permite a execução em fila pode conter variáveis membro de tipos de dados não primitivos, como sObjects ou tipos personalizados do Apex. Tais objetos podem ser acessados quando o trabalho for executado.
• Monitoramento: Quando você envia o trabalho invocando o método System.enqueueJob(), o método retorna a ID do registro AsyncApexJob. É possível usar este ID para identificar seu trabalho e monitorar seu progresso, seja pela interface de usuário do Salesforce, na página de Trabalhos do Apex, seja programaticamente pela consulta de seu registro em AsyncApexJob.
• Encadeamento de trabalhos: É possível encadear um trabalho a outro iniciando o segundo trabalho a partir de um trabalho em execução. O encadeamento de trabalhos é útil se você precisar fazer algum processamento sequencial.

@future
static void myFutureMethod(List<String> params) {
    // call synchronous method
    mySyncMethod(params);
}

public class SomeClass implements Queueable {
    public void execute(QueueableContext context) {
        // awesome code here
    }
}

Código de exemplo

Um cenário comum é pegar alguns conjuntos de registros sObject, executar algum processamento, como fazer um callout para um ponto de extremidade REST externo ou realizar alguns cálculos e então atualizá-los no banco de dados de forma assíncrona. Como os métodos @future são limitados a tipos de dados primitivos (ou matrizes ou coleções de dados primitivos), o Apex que permite a execução em fila é a opção ideal. O código a seguir pega uma coleção de registros de Conta, define a parentId para cada registro, e então atualiza os registros no banco de dados.

public class UpdateParentAccount implements Queueable {
    private List<Account> accounts;
    private ID parent;
    public UpdateParentAccount(List<Account> records, ID id) {
        this.accounts = records;
        this.parent = id;
    }
    public void execute(QueueableContext context) {
        for (Account account : accounts) {
          account.parentId = parent;
          // perform other processing or callout
        }
        update accounts;
    }
}

Para adicionar esta classe como um trabalho na fila, execute o seguinte código:

// find all accounts in ‘NY’
List<Account> accounts = [select id from account where billingstate = ‘NY’];
// find a specific parent account for all records
Id parentId = [select id from account where name = 'ACME Corp'][0].Id;
// instantiate a new instance of the Queueable class
UpdateParentAccount updateJob = new UpdateParentAccount(accounts, parentId);
// enqueue the job for processing
ID jobID = System.enqueueJob(updateJob);

Após enviar sua classe que permite a execução em fila para a execução, o trabalho será adicionado à fila e processado quando os recursos do sistema se tornarem disponíveis.

Você pode usar o novo ID para monitorar o progresso por meio da página de Trabalhos do Apex ou, programaticamente, consultando AsyncApexJob:

SELECT Id, Status, NumberOfErrors FROM AsyncApexJob WHERE Id = :jobID

@isTest
public class UpdateParentAccountTest {
    @testSetup
    static void setup() {
        List<Account> accounts = new List<Account>();
        // add a parent account
        accounts.add(new Account(name='Parent'));
        // add 100 child accounts
        for (Integer i = 0; i < 100; i++) {
            accounts.add(new Account(
                name='Test Account'+i
            ));
        }
        insert accounts;
    }
    static testmethod void testQueueable() {
        // query for test data to pass to queueable class
        Id parentId = [select id from account where name = 'Parent'][0].Id;
        List<Account> accounts = [select id, name from account where name like 'Test Account%'];
        // Create our Queueable instance
        UpdateParentAccount updater = new UpdateParentAccount(accounts, parentId);
        // startTest/stopTest block to force async processes to run
        Test.startTest();
        System.enqueueJob(updater);
        Test.stopTest();
        // Validate the job ran. Check if record have correct parentId now
        System.assertEquals(100, [select count() from account where parentId = :parentId]);
    }
}

public class FirstJob implements Queueable {
    public void execute(QueueableContext context) {
        // Awesome processing logic here
        // Chain this job to next job by submitting the next job
        System.enqueueJob(new SecondJob());
    }
}

• A execução de um trabalho em fila é contada uma vez para o limite compartilhado para execuções do método Apex assíncrono.
• Você pode adicionar até 50 trabalhos à fila com o System.enqueueJob em uma só transação.
• Ao encadear trabalhos, você só pode adicionar um trabalho a partir de um trabalho em execução com System.enqueueJob, o que significa que apenas um trabalho filho pode existir para cada trabalho pai que permite a execução em fila. Iniciar diversos trabalhos filhos no mesmo trabalho que permite a execução em fila não é aceitável.
• Nenhum limite é imposto à profundidade dos trabalhos encadeados, o que significa que você pode encadear um trabalho atrás do outro e repetir esse processo, encadeando-o a outro trabalho filho. Porém, para as versões de Developer Edition e Organizações de teste, a profundidade máxima da pilha para trabalhos encadeados é de cinco, o que significa que você pode encadear trabalhos quatro vezes e o número máximo de trabalhos na cadeia é de cinco, incluindo o trabalho que permite a execução em fila pai inicial.

• Apex Developer Guide: Apex que permite a execução em fila