Jedis et de la Laitue async capacités

Je suis en utilisant le redis avec Akka, donc je n'ai pas besoin de blocage des appels. La laitue est asynchrone de l'avenir d'appel intégrée. Mais Jedis est le client recommandé par le Redis. Quelqu'un peut-il me dire si je suis en utilisant à la fois de la bonne manière. Si oui lequel est le mieux.

JEDIS
Je suis l'aide d'une statique Jedis pool de connexion pour obtenir la con et à l'aide de Akka avenir de rappel pour traiter le résultat. Ma préoccupation ici est que lorsque j'utilise un autre thread (rachetable) pour obtenir le résultat que le thread est finalement va se bloquer pour la suite. Alors que la Laitue peut avoir une certaine façon la plus efficace de le faire.

 private final class OnSuccessExtension extends OnSuccess<String> {
            private final ActorRef senderActorRef;
            private final Object message;
            @Override
            public void onSuccess(String valueRedis) throws Throwable {
                log.info(getContext().dispatcher().toString());
                senderActorRef.tell((String) message, ActorRef.noSender());
            }
             public OnSuccessExtension(ActorRef senderActorRef,Object message) {
                    this.senderActorRef = senderActorRef;
                    this.message=message;
                }
        }
        ActorRef senderActorRef = getSender(); //never close over a future
            if (message instanceof String) {
        Future<String> f =akka.dispatch.Futures.future(new Callable<String>() {
                    public String call() {
                        String result;
                        try(Jedis jedis=JedisWrapper.redisPool.getResource()) {
                            result = jedis.get("name");
                        }
                        return result;
                    }
                }, ex);
                f.onSuccess(new OnSuccessExtension(senderActorRef,message), ex);
    }

LAITUE

ExecutorService executorService = Executors.newFixedThreadPool(10);
public void onReceive(Object message) throws Exception {
        ActorRef senderActorRef = getSender(); //never close over a future
        if (message instanceof String) {

            final RedisFuture<String> future = lettuce.connection.get("name");
            future.addListener(new Runnable() {
                final ActorRef sender = senderActorRef;
                final String msg =(String) message;
                @Override
                public void run() {
                    try {
                        String value = future.get();
                        log.info(value);
                        sender.tell(message, ActorRef.noSender());
                    } catch (Exception e) {
                    }
                }
            }, executorService);

Si la laitue est une meilleure option pour les appels Asynchrones. Alors quel est le type de l'exécuteur testamentaire dois-je aller avec un environnement de production. Si possible, pouvez-je utiliser un Akka répartiteur comme un contexte d'exécution pour Letture futur appel.

OriginalL'auteur cykopath | 2015-09-30