In Salesforce, Future Methods are used to run processes asynchronously. They allow you to execute long-running operations (such as callouts to external systems or complex calculations) in a separate thread, without blocking the main execution thread. This is particularly useful for improving performance and avoiding governor limits.
Key Considerations for Future Methods in Salesforce
- Annotation: Use the @future annotation before the method declaration to mark it as a future method. Example: @future
- Static and Void: Future methods must be static and can only return void (no return values).
- Parameter Restrictions: Parameters must be primitive data types (e.g., Integer, String, Boolean), arrays of primitive data types, or collections of primitive data types (e.g., List<Id>). Future methods cannot accept sObjects or complex objects as arguments.
- Invocation: Future methods are invoked like any other method. However, a future method cannot call another future method (no chaining).
- Governor Limits: No more than 50 future method calls per Apex transaction. The maximum number of future method invocations per 24-hour period is 250,000 or the number of user licenses multiplied by 200, whichever is greater.
- Testing Future Methods: Use Test.startTest() and Test.stopTest() to test future methods. Asynchronous calls made after startTest() are collected and executed synchronously when stopTest() is called.
- Asynchronous Execution: Future methods run asynchronously, meaning they execute in the background after the main transaction completes. Asynchronous calls (e.g., @future, executeBatch) made within a startTest(), stopTest() block do not count against queued job limits.
public class MyClass {
@future
public static void myFutureMethod(List<Id> recordIds) {
// Perform long-running operations or callouts here
}
}
Limitations of future methods
Future methods in Salesforce are powerful for handling asynchronous operations, but they come with several limitations that developers need to be aware of. Here’s a detailed list of the key limitations:
1. Parameter Restrictions
- Primitive Data Types Only: Future methods can only accept primitive data types (e.g., Integer, String, Boolean, Id, etc.), arrays of primitive data types, or collections of primitive data types (e.g., List<Id>).
- No sObjects or Complex Objects: Future methods cannot accept sObjects (e.g., Account, Contact) or complex objects (e.g., custom Apex classes) as parameters.
- Void Return Type: Future methods must return void. They cannot return values to the calling code, making it difficult to pass results back to the caller.
- No Guaranteed Order: The order in which future methods execute is not guaranteed. If you need sequential execution, consider using Queueable Apex instead.
4. Cannot Call Another Future Method
- No Chaining: A future method cannot call another future method. This limits the ability to chain asynchronous processes.
- 50 Future Calls per Transaction: You can only invoke 50 future methods in a single Apex transaction.
- 24-Hour Limit: The maximum number of future method invocations per 24-hour period is 250,000 or the number of user licenses multiplied by 200, whichever is greater.
- Separate Limits: Future methods have their own set of governor limits, which are separate from synchronous limits.
- Testing Requires startTest() and stopTest(): To test future methods, you must enclose the method call within Test.startTest() and Test.stopTest(). This ensures the future method executes synchronously during tests.
- No Direct Results: Since future methods do not return values, testing their outcomes can be more complex.
- Asynchronous Execution: Future methods run asynchronously, which means there may be a delay before they execute. This makes them unsuitable for tasks that require immediate results.
8. No Transaction Control
- Separate Transactions: Future methods run in a separate transaction from the calling code. This means: They do not have access to the uncommitted data from the calling transaction (e.g., records that were inserted but not yet committed) and they cannot roll back the calling transaction if an error occurs.
- Not Suitable for Real-Time Processing: Future methods are not ideal for real-time operations or tasks that require immediate feedback.
- No Support for DML on Setup Objects: Future methods cannot perform DML operations on setup objects (e.g., User, Profile, Group).
- Callouts Require @future(callout=true): If a future method makes an HTTP callout, it must be annotated with @future(callout=true). Without this, callouts are not allowed.
- Callout Timeout: Callouts in future methods are subject to a maximum timeout of 120 seconds.
- Asynchronous Nature: Debugging future methods can be challenging because they run in a separate thread. Logs for future methods are not immediately available and must be tracked separately.
12. No Support for Batch or Scheduled Jobs
- Cannot Be Used in Batch or Scheduled Jobs: Future methods cannot be invoked from Batch Apex or Scheduled Apex. For such use cases, consider using Queueable Apex or other asynchronous tools.
When to Avoid Future Methods
- When you need to return values to the calling code.
- When you require guaranteed execution order.
- When you need to perform real-time processing.
- When you need to chain asynchronous processes.
- When working with sObjects or complex objects as parameters.
Alternatives to Future Methods
- Queueable Apex: Supports chaining, complex objects, and more flexibility.
- Batch Apex: For processing large volumes of data asynchronously.
- Scheduled Apex: For running jobs at specific times.
Closing Note:
Thank you for taking the time to read my article! I’m passionate about Salesforce development and always eager to explore new challenges and opportunities. If you found this article insightful or would like to discuss Salesforce, innovative solutions, or potential collaborations, I’d love to connect!
P.S. I’m currently on the verge of completing my Master’s in Computer Science from California State University, Long Beach, and I’m actively seeking new opportunities as a Salesforce Developer in the USA. If you or your organization are looking for someone with a strong Salesforce skill set, a solid academic foundation, and a drive to deliver impactful solutions, feel free to reach out. Let’s connect and see how we can create something amazing together!
You can reach me via LinkedIn or at hgupta5746@gmail.com. Looking forward to connecting with fellow professionals and enthusiasts!
