public InterProcessMutex(CuratorFramework client, String path)

/**
* Acquire the mutex - blocking until it's available. Note: the same thread can call acquire
* re-entrantly. Each call to acquire must be balanced by a call to release()
*/
public void acquire()
/**
* Acquire the mutex - blocks until it's available or the given time expires. Note: the same 
* thread can call acquire re-entrantly. Each call to acquire that returns true must be 
* balanced by a call to release()
* Parameters:
* time - time to wait
* unit - time unit
* Returns:
* true if the mutex was acquired, false if not
*/
public boolean acquire(long time,
                       TimeUnit unit)

/**
* 将锁设为可撤销的. 当别的进程或线程想让你释放锁是Listener会被调用。
* Parameters:
* listener - the listener
*/
public void makeRevocable(RevocationListener<T> listener)

/**
* Utility to mark a lock for revocation. Assuming that the lock has been registered
* with a RevocationListener, it will get called and the lock should be released. Note,
* however, that revocation is cooperative.
* Parameters:
* client - the client
* path - the path of the lock - usually from something like 
* InterProcessMutex.getParticipantNodes()
*/
public static void attemptRevoke(CuratorFramework client,
                                 String path)
                         throws Exception

public LeaderLatch(CuratorFramework client, String latchPath)
public LeaderLatch(CuratorFramework client, String latchPath,  String id)

/**
     * Add this instance to the leadership election and attempt to acquire leadership.
     *
     * @throws Exception errors
     */
    public void start() throws Exception
    {
        Preconditions.checkState(state.compareAndSet(State.LATENT, State.STARTED), "Cannot be started more than once");
        startTask.set(AfterConnectionEstablished.execute(client, new Runnable()
                {
                    @Override
                    public void run()
                    {
                        try
                        {
                            internalStart();
                        }
                        finally
                        {
                            startTask.set(null);
                        }
                    }
                }));
    }

public boolean hasLeadership()

 public void await()
     throws InterruptedException, EOFException
   {
     synchronized (this)
     {
       while ((this.state.get() == State.STARTED) && (!this.hasLeadership.get()))
       {
         wait();
       }
     }
     if (this.state.get() != State.STARTED)
     {
       throw new EOFException();
     }
   }
Causes the current thread to wait until this instance acquires leadership
unless the thread is interrupted or closed.
public boolean await(long timeout,
                     TimeUnit unit)
            throws InterruptedException

@Test
public void test1() {
    CacheLoader<String, String> loader = new CacheLoader<String, String>() {
        @Override
        public String load(String key) throws Exception {
            System.out.println("call..");
            return key.toUpperCase();
        }
    };
    //fluent风格...
    LoadingCache<String, String> cache = CacheBuilder.newBuilder().build(loader);
    System.out.println(cache.size());
    System.out.println(cache.getUnchecked("aaa"));
    System.out.println(cache.size());
    System.out.println(cache.getUnchecked("aaa"));
    try {
        System.out.println(cache.get("cjp"));
    } catch (ExecutionException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

@Test
public void test2() throws Exception {
    //缓存同步删除
    LoadingCache<String, String> cache = CacheBuilder.newBuilder().expireAfterWrite(5, TimeUnit.SECONDS).maximumSize(3).recordStats().removalListener(new RemovalListener<String, String>() {
        @Override
        public void onRemoval(RemovalNotification<String, String> notification) {
            System.out.println("remove key[" + notification.getKey() + "],value[" + notification.getValue() + "],remove reason[" + notification.getCause() + "]");
            System.out.println("remove thread name " + Thread.currentThread().getName());
        }
    }).build(new CacheLoader<String, String>() {
        @Override
        public String load(String key) throws Exception {
            System.out.println("key[" + key + "] to upper case");
            return key.toUpperCase();
        }
    });
    System.out.println(cache.getUnchecked("a"));
    System.out.println(cache.getUnchecked("b"));
    System.out.println("thread name " + Thread.currentThread().getName());
    cache.invalidate("b");//删除key为b的值
    System.out.println(cache.getUnchecked("a"));
    Thread.sleep(5000);
    System.out.println(cache.getUnchecked("c"));
    System.out.println(cache.getUnchecked("a"));
    System.out.println(cache.stats().toString());
    System.out.println("end");
}

LoadingCache<String, String> cache = CacheBuilder.newBuilder().expireAfterWrite(5, TimeUnit.SECONDS).maximumSize(3).recordStats().removalListener(RemovalListeners.asynchronous(new RemovalListener<String, String>() {
    //删除缓存监听器异步删除
    @Override
    public void onRemoval(RemovalNotification<String, String> notification) {
        System.out.println("remove key[" + notification.getKey() + "],value[" + notification.getValue() + "],remove reason[" + notification.getCause() + "]");
        System.out.println("remove thread name " + Thread.currentThread().getName());
    }
}, Executors.newCachedThreadPool())).build(new CacheLoader<String, String>() {
    @Override
    public String load(String key) throws Exception {
        System.out.println("key[" + key + "] to upper case");
        return key.toUpperCase();
    }
});

@Test
public void test3() throws InterruptedException {
    LoadingCache<String, String> cache = CacheBuilder.newBuilder().recordStats().refreshAfterWrite(3, TimeUnit.SECONDS).build(new CacheLoader<String, String>() {
        @Override
        public String load(String key) throws Exception {
            System.out.println("load key[" + key + "]");
            return key.toUpperCase();
        }
        @Override
        public ListenableFuture<String> reload(String key, String oldValue) throws Exception {
            System.out.println("reload key[" + key + "],oldValue[" + oldValue + "]");
            return super.reload(key, oldValue);
        }
    });
    System.out.println(cache.getUnchecked("a"));
    System.out.println(cache.getUnchecked("b"));
    cache.refresh("a");
    Thread.sleep(3000);
    System.out.println(cache.getUnchecked("a"));
    System.out.println(cache.getUnchecked("c"));
}

/**
 * 缓存失效时异步重现加载，缓存调用者永远不用阻塞等
 *
 * @throws InterruptedException
 */
@Test
public void test4() throws InterruptedException {
    LoadingCache<String, String> cache = CacheBuilder.newBuilder().recordStats().refreshAfterWrite(3, TimeUnit.SECONDS).build(new CacheLoader<String, String>() {
        @Override
        public String load(String key) throws Exception {
            System.out.println("load key[" + key + "]");
            return key.toUpperCase();
        }
        @Override
        public ListenableFuture<String> reload(final String key, String oldValue) throws Exception {
            ListenableFutureTask<String> task = ListenableFutureTask.create(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    System.out.println("reload key[" + key + "] synchronize at thread[" + Thread.currentThread().getName() + "],this will take 1 second...");
                    Thread.sleep(1000);
                    System.out.println("reload end...");
                    return key.toUpperCase();
                }
            });
            Executors.newCachedThreadPool().execute(task);
            System.out.println("reload key[" + key + "],oldValue[" + oldValue + "]");
            return task;
        }
    });
    //注意：如果重来没有被get过，在缓存中完全没有，第一次调用会执行load，然后加入到cache中，只有被加入到其中的
    //到达失效时间后，再被加载的时候才会触发reload
    System.out.println(cache.getUnchecked("a"));
    System.out.println(cache.getUnchecked("b"));
    cache.refresh("a");
    Thread.sleep(3000);
    //这里的取a 不会触发reload，因为上面refresh需要耗1s才能结束，而主线程这里只需要等3s
    //所以这里的a还有1s的存活时间
    System.out.println(cache.getUnchecked("a"));
    //但是这里的b 就必须reload了，但是reload的过程需要注意下：先调用load方法，然后发现失效了，但是还会返回之前
    //缓存中的值，同时会加载reload，因为是异步reload，主线程这里不用等reload结束，继续向下运行获取c的值
    System.out.println(cache.getUnchecked("b"));
    System.out.println(cache.getUnchecked("c"));
    //这里再暂停5s是为了看清楚上面reload b的结束
    Thread.sleep(5000);
}