Mastering Async Apex in Salesforce: Batch, Queueable, Scheduled & Future

Asynchronous Apex is a cornerstone of scalable and efficient Salesforce development. It allows you to offload long-running processes from the main transaction, improve governor limits, and enhance user experience. In this guide, we’ll explore the four primary asynchronous Apex constructs—Batch Apex, Queueable Apex, Scheduled Apex, and Future Apex—along with their use cases, code examples, and best practices.

1. Batch Apex: Processing Large Datasets

Problem:
When dealing with large datasets (e.g., processing 50,000+ records), synchronous Apex hits heap size or CPU time limits. Batch Apex solves this by breaking the job into smaller chunks and executing them asynchronously.

Solution:
Batch Apex uses the Database.Batchable interface to process records in manageable batches.

Example: Batch Apex for Data Processing

public class ProcessLargeDataBatch implements Database.Batchable<sObject> {  
    public Database.QueryLocator start(Database.BatchableContext bc) {  
        return Database.getQueryLocator([SELECT Id, Name FROM Account WHERE Industry = 'Technology']);  
    }  

    public void execute(Database.BatchableContext bc, List<Account> scope) {  
        for (Account acc : scope) {  
            acc.Industry = 'Processed';  
        }  
        update scope;  
    }  

    public void finish(Database.BatchableContext bc) {  
        // Optional cleanup or notifications  
    }  
}

How to Execute:

Id batchId = Database.executeBatch(new ProcessLargeDataBatch(), 200);

Key Points:

Batches process records in chunks (default: 200, configurable).
Use Database.BatchableContext to track job progress.
Ideal for bulk operations like data migration or complex calculations.

2. Queueable Apex: Flexible Asynchronous Execution

Problem:
While Batch Apex is great for bulk operations, it lacks flexibility in chaining jobs or passing parameters. Queueable Apex fills this gap with its ability to enqueue jobs and chain them sequentially.

Solution:
Queueable Apex implements the System.Queueable interface and supports constructor parameters.

Example: Queueable Apex for Chaining Jobs

public class ProcessDataQueueable implements System.Queueable {  
    private String recordId;  

    public ProcessDataQueueable(String recordId) {  
        this.recordId = recordId;  
    }  

    public void execute(QueueableContext context) {  
        Account acc = [SELECT Id, Name FROM Account WHERE Id = :recordId];  
        acc.Name = acc.Name + '_Processed';  
        update acc;  

        // Chain another job  
        System.enqueueJob(new AnotherQueueable());  
    }  
}

How to Execute:

System.enqueueJob(new ProcessDataQueueable('001XXXXXXXXXXXX'));

Key Points:

Supports constructor arguments.
Can chain jobs using System.enqueueJob().
No limit on execution time (unlike Future).

3. Scheduled Apex: Automating Recurring Tasks

Problem:
Many business processes (e.g., end-of-day reports, data cleanup) require periodic execution.

Solution:
Scheduled Apex uses System.Schedulable to run Apex code at a specified time.

Example: Scheduled Apex for Daily Cleanup

public class DailyCleanup implements Schedulable {  
    public void execute(SchedulableContext sc) {  
        List<Account> oldAccounts = [SELECT Id FROM Account WHERE LastModifiedDate < LAST_N_DAYS:7];  
        delete oldAccounts;  
    }  
}

How to Schedule:

String cronExpr = '0 0 2 * * ?'; // Runs daily at 2 AM  
System.schedule('Daily Cleanup Job', cronExpr, new DailyCleanup());

Key Points:

Use cron expressions for scheduling.
Maximum 50 scheduled jobs per org.
Monitor jobs via Setup → Apex Jobs.

4. Future Apex: Asynchronous Execution with Limits

Problem:
You need to call an external API or perform a long-running operation without blocking the user.

Solution:
Future Apex uses the System.Runnables interface to execute methods asynchronously.

Example: Future Apex for External Callout

public class CalloutFuture implements System.Runnables {  
    public void runTimed() {  
        HttpRequest req = new HttpRequest();  
        req.setEndpoint('https://api.example.com/data');  
        req.setMethod('GET');  
        Http http = new Http();  
        HTTPResponse res = http.send(req);  
    }  
}

How to Execute:

System.enqueueJob(new CalloutFuture());

Key Points:

Maximum execution time: 10 seconds.
Limited to 25 queued jobs per 24 hours (configurable).
Not suitable for bulk operations.

Choosing the Right Async Apex Tool

Type	Use Case	Max Execution Time	Chaining
Batch Apex	Bulk data processing	10 mins per execution	No
Queueable Apex	Flexible, parameterized jobs	10 mins	Yes
Scheduled Apex	Recurring tasks	10 mins	No
Future Apex	External callouts, short tasks	10 seconds	No

Conclusion

Async Apex is indispensable for building scalable Salesforce applications. By leveraging:

Batch Apex for bulk operations,
Queueable Apex for flexible workflows,
Scheduled Apex for automation, and
Future Apex for lightweight async tasks,

you can optimize performance, avoid governor limits, and enhance user experience. Always monitor Apex Jobs (Setup → Apex Jobs) to debug and optimize your asynchronous processes.

With these tools mastered, you’re ready to tackle complex Salesforce scenarios efficiently!

Please Wait

Comments (0)