Using futures for making parallel redis cache calls

Question

I'm trying to do a multi-get on my redis data store which is distributed across multiple shards. However the keys I want to do this on do not belong to the same shard so I can't use redis' inbuilt multi-get.

Instead I'm trying to use futures to achieve this. But after checking the lookup times it almost seems like these cache calls are being made serially.

The request/sec on the server is about 1.5k with an average of 10 ms response time. Literature I've read told me that my threadpool size should be requests/sec * response time. Since I'm spawning 3 threads this becomes 1500 * 0.010 * 3 = 45. I've tried using threadpool sizes of 50,100,300. But this hasn't helped either.

I'm using Jedis as a client. I thought it could be an issue with exceeding Jedis' max total/idle connection limit. But even after increasing this from 8 to 24 I see no difference in lookup times.

I understand that some overhead will be there since there will be context switches and the overhead of spawning new threads.

Can anyone help me figure out where I'm missing out. Let me know if you need more info.

                for(String recordKey : pidArr) {
                //Adding futures. Max 3
                if(count >= 3) {
                    break;
                }
                count++;
                Callable<String> a = new FeedCacheCaller(recordKey);

                Future<String> future = feedThreadPool.submit(a);
                futureList.add(future);
            }

            //Getting the data from the futures

            for(Future<String> foo : futureList) {
                try {
                    String data = foo.get();
                    logger.debug(data);
                    feedDataList.add(parseInfo(data));

                } catch (Exception e) {
                    logger.error("somethings going wrong in retrieval",e);
                }
            }

Here's the Callable class

public class FeedCacheCaller implements Callable {

String pid = null;
FeedCache feedCache;
public FeedCacheCaller(String pid) {
    this.pid = pid;
    this.feedCache =  new FeedCache();
}
@Override
public String call() throws Exception {
    return feedCache.get(pid);
}

}

Edit 1:

Here's the Jedis side code.

    public class FeedCache {

    private ShardedJedisPool feedClient = RedisPool.getPool("feed");

    public String get(String key) {
    ShardedJedis client = null;
    String value = null;
    try {
        client = feedClient.getResource();
        byte[] valueByteArray = client.get(key.getBytes(Constants.CHARSET));
        if (valueByteArray != null) {
            value = new String(CacheUtils.decompress(valueByteArray),
                               Constants.CHARSET);
        }
    } catch (JedisConnectionException e) {
        if (client != null) {
            feedClient.returnBrokenResource(client);
            client = null;
        }
        logger.error(e.getMessage());
    } finally {
        if (client != null) {
            feedClient.returnResource(client);
        }
    }

    return value;
}

}

Here is the code that initializes the ShardedJedisPool

public class RedisPool {

private static final Logger logger = LoggerFactory.getLogger(
        RedisPool.class);

private static ConcurrentHashMap<String, ShardedJedisPool> redisPools = new ConcurrentHashMap<String, ShardedJedisPool>();

public static void initializePool(String poolName) {
    List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
    ArrayList<String> servers = new ArrayList<String>(Arrays.asList(
            Constants.config.getStringArray(
                poolName + "_redis_servers")));
    for (int i = 0; i < servers.size(); i++) {
        JedisShardInfo shardInfo = new JedisShardInfo(servers.get(i).split(":")[0], Integer.parseInt(servers.get(i).split(":")[1]));
        shards.add(shardInfo);
    }
    redisPools.putIfAbsent(poolName,
            new ShardedJedisPool(new GenericObjectPoolConfig(), shards));
}

public static ShardedJedisPool getPool(String poolName) {
    if (!redisPools.containsKey(poolName)) {
        synchronized (RedisPool.class) {
            if (!redisPools.containsKey(poolName)) {
                initializePool(poolName);
            }
        }
    }
    return redisPools.get(poolName);
}

public static void shutdown(String poolName) {
    ShardedJedisPool pool = getPool(poolName);
    pool.destroy();
    redisPools.remove(poolName);
}

public static void main(String args[]) {
    initializePool("vizidtoud");
}

}