import net.spy.memcached.internal.GetFuture; //导入依赖的package包/类
public Object get(String key)
    {
        if (! isActive())
            return null;
        
        Object result = null;
        final GetFuture<Object> f = memcachedClient.get().asyncGet(key);
        try
        {
            result = f.get(TIMEOUT, TimeUnit.MILLISECONDS);
        }
        catch (Exception e)
        {
            f.cancel(true);
        }
        return result;
//        return memcachedClient.get(key); // sync version
    }
 

import net.spy.memcached.internal.GetFuture; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void shouldGetItem() throws InterruptedException, TimeoutException, ExecutionException {
    // Given
    final String key = Randoms.randomString();
    final String item = Randoms.randomString();
    final int timeout = Randoms.randomInt(5) + 1;
    final GetFuture<Object> f = mock(GetFuture.class);
    when(memcachedClient.asyncGet(key)).thenReturn(f);
    when(f.get(timeout, TimeUnit.SECONDS)).thenReturn(item);

    // When
    final Object obj = memcachedItemCache.getItem(key, timeout);

    // Then
    assertEquals(item, obj);
}
 

import net.spy.memcached.internal.GetFuture; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void shouldNotGetItem_throwsTimeout() throws InterruptedException, ExecutionException, TimeoutException {
    // Given
    final String key = Randoms.randomString();
    final int timeout = Randoms.randomInt(5) + 1;
    final GetFuture<Object> f = mock(GetFuture.class);
    when(memcachedClient.asyncGet(key)).thenReturn(f);
    when(f.get(timeout, TimeUnit.SECONDS)).thenThrow(TimeoutException.class);

    // When
    final Object item = memcachedItemCache.getItem(key, timeout);

    // Then
    assertNull(item);
}
 

import net.spy.memcached.internal.GetFuture; //导入依赖的package包/类
private Object get(String key) {
    GetFuture<Object> future = client.asyncGet(key);
    try {
        return future.get(config.getCacheGetTimeoutInMillis(), TimeUnit.MILLISECONDS);
    } catch(Exception e) {
        log.warn("{\"method\":\"get\",\"exception\":\"{}\",\"message\":\"Exception whilst attempting get from memcached for key\",\"key\":\"{}\"}",e.getMessage(),key);
        return null;
    }
}
 

import net.spy.memcached.internal.GetFuture; //导入依赖的package包/类
@Override
public void get(String key, CountDownLatch countDownLatch) throws Exception {
  ((GetFuture<Object>) client.asyncGet(key))
    .addListener(future -> countDownLatch.countDown());
}
 

import net.spy.memcached.internal.GetFuture; //导入依赖的package包/类
public <T> GetFuture<T> asyncGet(final String key, final Transcoder<T> tc) {
    throw new UnsupportedOperationException("asyncGet");
}
 

import net.spy.memcached.internal.GetFuture; //导入依赖的package包/类
/**
 * Get the given key asynchronously and decode with the default transcoder.
 *
 * @param key the key to fetch
 * @return a future that will hold the return value of the fetch
 * @throws IllegalStateException in the rare circumstance where queue is too
 * full to accept any more requests
 */
public GetFuture<Object> asyncGet(final String key) {
    return asyncGet(key, transcoder);
}