The @future annotation (pronounced as at future) is, perhaps, the simplest method of asynchronous code execution on the Salesforce1 platform. The @future, is a method annotation that makes the method run asynchronously at some point in the near future. Generally, this happens quite quickly, but no time guarantees are established annotation methods as @future is fantastically useful, but has a number of caveats and limitations that developers must remain mindful of:

These caveats and limitations should not deter you from using the @future annotation. Indeed, the biggest limitation that—parameters must be primitives—can be easily overcome with a bit of clever programming. For example, while an @future method cannot take sObjects for parameters, it can accept a string. Even a string resulting from the JSON serialization of an sObject, or list of sObjects. The following is an example of this pattern:

Public with sharing class Examples {
  @future
  Public public Static Void void myAtFutureMethod(String jsonStringOfAccount){
    Account a = (Account) JSON.deserialize(jsonStringOfAccount, Account.class);
    //do work with your sObject
  }
}

One of the best features of the @future annotated methods is that they can be used to execute callouts. If, for instance, you are integrating with an external API that takes a while to return, you can make the callout from an @future method rather than, say, your Visualforce controller. To enable the callout feature of the @future methods, append the option callout=true to your @future annotation. Methods annotated with the @future annotations with callouts work best when you are creating net-new related records. If you are editing an existing record, you will likely end up in a situation where the @future method executes the DML to update the record. If there are triggers calling the @future methods set on the same object—a common enough occurrence— you will inadvertently end up throwing an exception trying to execute an @future method from within an @future context.