Google guava cache源码解析1--构建缓存器（1）

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

public class Hello{
    
    LoadingCache<String, String> testCache = CacheBuilder.newBuilder()
            .expireAfterWrite(20, TimeUnit.MINUTES)// 缓存20分钟
            .maximumSize(1000)// 最多缓存1000个对象
            .build(new CacheLoader<String, String>() {
                public String load(String key) throws Exception {
                    if(key.equals("hi")){
                        return null;
                    }
                    return key+"-world";
                }
            });
    
    public static void main(String[] args){
        Hello hello = new Hello();
        System.out.println(hello.testCache.getIfPresent("hello"));//null
        hello.testCache.put("123", "nana");//存放缓存
        System.out.println(hello.testCache.getIfPresent("123"));//nana
        try {
            System.out.println(hello.testCache.get("hello"));//hello-world
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(hello.testCache.getIfPresent("hello"));//hello-world
        /***********测试null*************/
        System.out.println(hello.testCache.getIfPresent("hi"));//null
        try {
            System.out.println(hello.testCache.get("hi"));//抛异常
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        
    }
}

    LoadingCache<String, String> testCache = CacheBuilder.newBuilder()
            .expireAfterWrite(20, TimeUnit.MINUTES)// 缓存20分钟(时间起点：entry的创建或替换（即修改）)
            //.expireAfterAccess(10, TimeUnit.MINUTES)//缓存10分钟(时间起点：entry的创建或替换（即修改）或最后一次访问)
            .maximumSize(1000)// 最多缓存1000个对象
            .build(new CacheLoader<String, String>() {
                public String load(String key) throws Exception {
                    if(key.equals("hi")){
                        return null;
                    }
                    return key+"-world";
                }
            });

    private static final int DEFAULT_INITIAL_CAPACITY = 16;//用于计算每个Segment中的hashtable的大小
    private static final int DEFAULT_CONCURRENCY_LEVEL = 4;//用于计算有几个Segment
    private static final int DEFAULT_EXPIRATION_NANOS = 0;//默认的缓存过期时间
    
    static final int UNSET_INT = -1;
    
    int initialCapacity = UNSET_INT;//用于计算每个Segment中的hashtable的大小
    int concurrencyLevel = UNSET_INT;//用于计算有几个Segment
    long maximumSize = UNSET_INT;//cache中最多能存放的缓存entry个数
    long maximumWeight = UNSET_INT;
    
    Strength keyStrength;//键的引用类型（strong、weak、soft）
    Strength valueStrength;//值的引用类型（strong、weak、soft）

    long expireAfterWriteNanos = UNSET_INT;//缓存超时时间（起点：缓存被创建或被修改）
    long expireAfterAccessNanos = UNSET_INT;//缓存超时时间（起点：缓存被创建或被修改或被访问）

    /**
     * 采用默认的设置（如下）创造一个新的CacheBuilder实例
     * 1、strong keys
     * 2、strong values
     * 3、no automatic eviction of any kind.
     */
    public static CacheBuilder<Object, Object> newBuilder() {
        return new CacheBuilder<Object, Object>();//new 一个实例
    }

    /**
     * 指明每一个entry（key-value）在缓存中的过期时间
     * 1、时间的参考起点：entry的创建或值的修改
     * 2、过期的entry也许会被计入缓存个数size（也就是说缓存个数不仅仅只有存活的entry）
     * 3、但是过期的entry永远不会被读写
     */
    public CacheBuilder<K, V> expireAfterWrite(long duration, TimeUnit unit) {
        /*
         * 检查之前是否已经设置过缓存超时时间
         */
        checkState(expireAfterWriteNanos == UNSET_INT,//正确条件：之前没有设置过缓存超时时间
                   "expireAfterWrite was already set to %s ns",//不符合正确条件的错误信息
                   expireAfterWriteNanos);
        /*
         * 检查设置的超时时间是否大于等于0，当然，通常情况下，我们不会设置缓存为0
         */
        checkArgument(duration >= 0, //正确条件
                      "duration cannot be negative: %s %s",//不符合正确条件的错误信息，下边的是错误信息中的错误参数
                      duration, 
                      unit);
        this.expireAfterWriteNanos = unit.toNanos(duration);//根据输入的时间值与时间单位，将时间值转换为纳秒
        return this;
    }