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
Vous devez vous connecter pour publier un commentaire.
Il n'y a pas de réponse à votre question, car elle dépend.
Jedis et la laitue sont à la fois clients matures. Pour compléter la liste des clients Java, il y a aussi Redisson, ce qui ajoute une couche d'abstraction (Collecte/File/Lock/interfaces... au lieu de raw Redis commandes).
Jolie beaucoup dépend de la façon dont vous travaillez avec les clients. En général, Redis est monothread en termes d'accès aux données, de sorte que le seul avantage de vous gagner par la simultanéité est déchargement le protocole e/S et de travail pour les différents threads. Qui n'est pas entièrement fidèle à la laitue et Redisson car ils utilisent netty sous le capot (netty lie une prise de canal à un événement particulier de la boucle de fil).
Avec les Jedis, vous pouvez utiliser uniquement une connexion avec un seul thread à la fois. Qui corrèle bien avec la Akka acteur de modèle, car un acteur instance est occupée que par un seul thread à la fois.
De l'autre côté, vous aurez besoin de beaucoup de Jedis comme des connexions de fils qui traitent avec un acteur particulier. Si vous commencez à partager Jedis que les connexions entre les différents acteurs, vous pouvez soit aller pour le regroupement de connexion, ou vous avez besoin d'avoir un dédié Jedis connexion par acteur de l'instance. Veuillez garder à l'esprit que vous devez prendre soin de la reconnexion (une fois Redis connexion est rompue) par vous-même.
Avec Redisson et la laitue, vous obtenez transparent reconnexion si vous le souhaitez (C'est la valeur par défaut de la laitue, pas sûr au sujet de Redisson).
Par l'aide de la laitue et de la Redisson vous pouvez partager une connexion entre tous les acteurs parce qu'ils sont thread-safe. Vous ne pouvez pas partager une laitue de connexion dans les deux cas:
MULTI
/EXEC
, puisque vous mélange de différentes opérations avec les opérations et qui est certainement une chose que vous ne voulez pas le faire)Jedis n'a pas d'interface asynchrone, donc, vous êtes tenus de le faire par vous-même. C'est faisable, et j'ai fait quelque chose de similaire avec MongoDB, le déchargement/découplage de l'I/O partie à d'autres acteurs. Vous pouvez utiliser l'approche à partir de votre code, mais vous n'êtes pas tenu de fournir un exécuteur de service parce que vous n'avez non-blocage des opérations dans l'exécutable de l'auditeur.
Avec de la laitue 4.0, vous aurez Java 8 support (qui est meilleur en termes de l'API asynchrone en raison de la CompletionStage interface), et vous pouvez même utiliser RxJava (réactif de programmation) à l'approche de la simultanéité.
La laitue n'est pas d'opinions sur votre modèle d'accès simultané. Il vous permet de l'utiliser selon vos besoins, à l'exception de la plaine
Future
/ListenableFuture
API de Java 6/7 et Goyave n'est pas très agréable à utiliser.HTH, Marque
OriginalL'auteur mp911de
Donner un essai à Redisson cadre. Il fournit une API Asynchrone ainsi que les API de Flux pris en charge grâce à l'intégration du Projet de Réacteur et RxJava2 libs.
Asynchrone, utilisation de l'API exemple:
Réactives de l'API de Flux avec le Projet de Réacteur lib exemple d'utilisation:
Réactives de l'API de Flux avec RxJava2 lib exemple d'utilisation:
OriginalL'auteur Nikita Koksharov