According to p.1 "API changes require discussion, use cases, etc. Code comes later.", I'm going to start discussion about benefits of proposed changes. 

Now com.google.common.cache.CacheBuilder contains such methods as
`refreshAfterWrite(long duration, TimeUnit unit)`
`expireAfterWrite(long duration, TimeUnit unit)`
`expireAfterAccess(long duration, TimeUnit unit)`
Parameters of methods listed below are used to define durations in time.
However, in Java 8 new class,  [java.time.Duration](https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html), was presented. It can be used to save info about time durations in exactly one object. That is easier and more transparent in some real-world scenarios. 

The idea is to add overloaded methods:
`refreshAfterWrite(Duration duration)
expireAfterWrite(Duration duration)
expireAfterAccess(Duration duration)`

Proposed changes provide possibilities to simplify code:
`expireAfterWrite(Duration.ofHours(3))
// instead of
expireAfterWrite(3, TimeUnit.HOURS)
`
It makes easier to declare constant durations too:

`public static final Duration EXPIRES_IN = Duration.ofHours(1);
// some code after statement
expireAfterWrite(EXPIRES_IN)
`
instead of
`public static final long DURATION_LENGTH = 1;
 public static final TimeUnit DURATION_TIME_UNIT = TimeUnit.HOURS;
 // some code after statement
 expireAfterWrite(DURATION_LENGTH, DURATION_TIME_UNIT)
`

Also, it allows to execute some arifmetic operations like addition or subtraction, that can simplify program logic if multiple (and dependant) durations in different methods and/or in different caches are used. Just something like this (simplified synthetic example):
`
Duration expiresAfterAccessIn = Duration.ofMinutes(30);
CacheBuilder.newBuilder()
                    .expireAfterAccess(expiresAfterAccessIn)
                    .expireAfterWrite(expiresAfterAccessIn.plusHours(1))
                    .build();
`

This improvements do not lead to changing min java sdk version and do not break existing API.
*
   * <p>Defaults to 4. <b>Note:</b>The default may change in the future. If you care about this
   * value, you should always choose it explicitly.
   *
   * <p>The current implementation uses the concurrency level to create a fixed number of hashtable
   * segments, each governed by its own write lock. The segment lock is taken once for each explicit
   * write, and twice for each cache loading computation (once prior to loading the new value, and
   * once after loading completes). Much internal cache management is performed at the segment
   * granularity. For example, access queues and write queues are kept per segment when they are
   * required by the selected eviction algorithm. As such, when writing unit tests it is not
   * uncommon to specify {@code concurrencyLevel(1)} in order to achieve more deterministic eviction
   * behavior.
   *
   * <p>Note that future implementations may abandon segment locking in favor of more advanced
   * concurrency controls.
   *
   * @return this {@code CacheBuilder} instance (for chaining)
   * @throws IllegalArgumentException if {@code concurrencyLevel} is nonpositive
   * @throws IllegalStateException if a concurrency level was already set
   */
  public CacheBuilder<K, V> concurrencyLevel(int concurrencyLevel) {
    checkState(
        this.concurrencyLevel == UNSET_INT,
        "concurrency level was already set to %s",
        this.concurrencyLevel);
    checkArgument(concurrencyLevel > 0);
    this.concurrencyLevel = concurrencyLevel;
    return this;
  }
  int getConcurrencyLevel() {