code: public List<Duration> calculatePreciseDuration(Date then)
     {
        if (then == null)
           then = now();
  
        Date reference = this.reference;
        if (null == reference)
           reference = now();
  
        List<Duration> result = new ArrayList<Duration>();
        long difference = then.getTime() - reference.getTime();
        Duration duration = calculateDuration(difference);
        result.add(duration);
        while (0 != duration.getDelta())
        {
           duration = calculateDuration(duration.getDelta());
           if (result.size() > 0)
           {
              Duration last = result.get(result.size() - 1);
              if (last.getUnit().equals(duration.getUnit()))
              {
                 break;
              }
           }
  
           if (duration.getUnit().isPrecise())
              result.add(duration);
        }
        return result;
     }
docs: Calculate to the precision of the smallest provided {@link TimeUnit}, the exact {@link Duration} represented by
  the difference between the reference {@link Date}, and the given {@link Date}. If the given {@link Date} is
  <code>null</code>, the current value of {@link System#currentTimeMillis()} will be used instead.
  <p>
  <b>Note</b>: Precision may be lost if no supplied {@link TimeUnit} is granular enough to represent the remainder
  of time (in milliseconds).
  
  @param then The {@link Date} to be compared against the reference timestamp, or <i>now</i> if no reference
  timestamp was provided
  @return A sorted {@link List} of {@link Duration} objects, from largest to smallest. Each element in the list
  represents the approximate duration (number of times) that {@link TimeUnit} to fit into the previous
  element's delta. The first element is the largest {@link TimeUnit} to fit within the total difference
  between compared dates.