Retrying Operations in Java

There are many cases in which you may wish to retry an operation a certain number of times. Examples are database failures, network communication failures or file IO problems.
Approach 1
This is the traditional approach and involves a counter and a loop.

final int numberOfRetries = 5 ; final long timeToWait = 1000 ;   for (int i=0; i<numberOfRetries; i++) {  //perform the operation  try {   Naming.lookup("rmi://localhost:2106/MyApp");   break;  }  catch (Exception e) {   logger.error("Retrying...",e);   try {    Thread.sleep(timeToWait);   }   catch (InterruptedException i) {   }  } }

Approach 2
In this approach, we hide the retry counter in a separate class called RetryStrategy and call it like this:

public class RetryStrategy {  public static final int DEFAULT_NUMBER_OF_RETRIES = 5;  public static final long DEFAULT_WAIT_TIME = 1000;    private int numberOfRetries; //total number of tries  private int numberOfTriesLeft; //number left  private long timeToWait; //wait interval    public RetryStrategy()  {   this(DEFAULT_NUMBER_OF_RETRIES, DEFAULT_WAIT_TIME);  }    public RetryStrategy(int numberOfRetries, long timeToWait)  {   this.numberOfRetries = numberOfRetries;   numberOfTriesLeft = numberOfRetries;   this.timeToWait = timeToWait;  }    /**   * @return true if there are tries left   */  public boolean shouldRetry()  {   return numberOfTriesLeft > 0;  }    /**   * This method should be called if a try fails.   *   * @throws RetryException if there are no more tries left   */  public void errorOccured() throws RetryException  {   numberOfTriesLeft --;   if (!shouldRetry())   {    throw new RetryException(numberOfRetries +      " attempts to retry failed at " + getTimeToWait() +      "ms interval");   }   waitUntilNextTry();  }    /**   * @return time period between retries   */  public long getTimeToWait()  {   return timeToWait ;  }    /**   * Sleeps for the duration of the defined interval   */  private void waitUntilNextTry()  {   try   {    Thread.sleep(getTimeToWait());   }   catch (InterruptedException ignored) {}  }    public static void main(String[] args) {   RetryStrategy retry = new RetryStrategy();   while (retry.shouldRetry()) {    try {     Naming.lookup("rmi://localhost:2106/MyApp");     break;    }    catch (Exception e) {     try {      retry.errorOccured();     }     catch (RetryException e1) {      e.printStackTrace();     }    }   }  } }

Approach 3
Approach 2, although cleaner, hasn't really reduced the number of lines of code we have to write. In the next approach, we hide the retry loop and all logic in a separate class called RetriableTask. We make the operation that we are going to retry Callable and wrap it in a RetriableTask which then handles all the retrying for us, behind-the-scenes:

public class RetriableTask<T> implements Callable<T> {    private Callable<T> task;  public static final int DEFAULT_NUMBER_OF_RETRIES = 5;  public static final long DEFAULT_WAIT_TIME = 1000;    private int numberOfRetries; // total number of tries  private int numberOfTriesLeft; // number left  private long timeToWait; // wait interval    public RetriableTask(Callable<T> task) {   this(DEFAULT_NUMBER_OF_RETRIES, DEFAULT_WAIT_TIME, task);  }    public RetriableTask(int numberOfRetries, long timeToWait,                       Callable<T> task) {   this.numberOfRetries = numberOfRetries;   numberOfTriesLeft = numberOfRetries;   this.timeToWait = timeToWait;   this.task = task;  }    public T call() throws Exception {   while (true) {    try {     return task.call();    }    catch (InterruptedException e) {     throw e;    }    catch (CancellationException e) {     throw e;    }    catch (Exception e) {     numberOfTriesLeft--;     if (numberOfTriesLeft == 0) {      throw new RetryException(numberOfRetries +      " attempts to retry failed at " + timeToWait +      "ms interval", e);     }     Thread.sleep(timeToWait);    }   }  }    public static void main(String[] args) {   Callable<Remote> task = new Callable<Remote>() {    public Remote call() throws Exception {     String url="rmi://localhost:2106/MyApp";     return (Remote) Naming.lookup(url);    }   };     RetriableTask<Remote> r = new RetriableTask<Remote>(task);   try {    r.call();   }   catch (Exception e) {    e.printStackTrace();   }  } }