De um modo geral, depois que o cliente Redis emite uma solicitação, ele geralmente bloqueia e aguarda o processo do Redis Server. Depois que o servidor Redis concluir o processamento, ele retornará o resultado ao cliente através da mensagem de resposta depois de solicitar o comando.
Parece que isso é um pouco parecido com a varredura do HBase. Geralmente, o cliente recebe cada registro e chama o servidor de uma só vez.
Em Redis, existe algo semelhante ao cache de scanner de hbase, que retorna vários registros a uma solicitação?
Sim, isso é PIPLINE. Introdução oficial http://redis.io/topics/pipelining
Quando há grandes lotes de operações através do pipeline, podemos economizar muito tempo desperdiçado em atrasos na rede. Deve -se notar que os comandos são embalados e enviados usando o pipeline. Redis deve cache os resultados do processamento de todos os comandos antes de processar todos os comandos. Quanto mais comandos você empacotar, mais memória você consome. Portanto, não é que os comandos mais embalados, melhor.
Ao usar o pipeline, o desempenho foi bastante aprimorado ao ler e escrever redis em lotes.
Java testou:
pacote com.lxw1234.redis; importar java.util.hashmap; importar java.util.map; importar java.util.set; importar redis.cliients.jedis.jedis; import.cliients.jedis.pipeline; Redis = novo Jedis ("127.0.0.1", 6379, 400000); Mapa <string, string> data = new hashmap <string, string> (); Redis.Select (8); redis.flushdb (); // hmset long start = system.currenttimemillis (); // hmset direto para (int i = 0; i <10000; i ++) {data.clear (); data.put ("k_" + i, "v_" + i); redis.hmset ("key_" + i, dados); } long end = System.currenttimemillis (); System.out.println ("dbsize: [" + redis.dbsize () + "] .."); System.out.println ("hmset sem tubulação usada [" + (end - start) / 1000 + "] segundos .."); Redis.Select (8); redis.flushdb (); // Use o pipeline da tubulação Hmset p = redis.pipelined (); start = system.currenttimemillis (); for (int i = 0; i <10000; i ++) {data.clear (); data.put ("k_" + i, "v_" + i); p.hmset ("key_" + i, dados); } p.sync (); end = system.currenttimemillis (); System.out.println ("dbsize: [" + redis.dbsize () + "] .."); System.out.println ("hmset com pipeline usado [" + (end - start) / 1000 + "] segundos .."); // hmget set <string> keys = redis.keys ("*"); // Use Jedis hgetall start = system.currenttimemillis (); Mapa <string, mapa <string, string >> resultado = novo hashmap <string, mapa <string, string >> (); para (chave de string: chaves) {result.put (chave, redis.hgetall (key)); } end = System.currenttimemillis (); System.out.println ("Tamanho do resultado: [" + resultado.size () + "] .."); System.out.println ("hgetall sem pipeline usada [" + (end - start) / 1000 + "] segundos .."); // Use o pipeline hgetall map <string, resposta <map <string, string >>>> respostas = novo hashmap <string, resposta <map <string, string >>> (keys.size ()); resultado.clear (); start = system.currenttimemillis (); para (chave de string: chaves) {Respondes.put (key, p.hgetall (key)); } p.sync (); for (String K: Responses.KeySet ()) {Result.put (K, Responses.get (k) .get ()); } end = System.currenttimemillis (); System.out.println ("Tamanho do resultado: [" + resultado.size () + "] .."); System.out.println ("HGETALL com pipeline usado [" + (end - start) / 1000 + "] segundos .."); redis.disconnect (); }} Os resultados dos testes são os seguintes:
DBSize: [10000] .. Hmset sem pipeline usado [243] segundos .. dbsize: [10000] .. hmset com pipeline usado [0] segundos .. Tamanho do resultado: [10000] .. HGETALL sem pipeline usado [243] segundos .. Tamanho do resultado: [10000] .. HGETALL com pipeline usado [0] segundos ..
Usar o pipeline para ler e escrever 10.000 registros em lotes é um pedaço de bolo e será feito em segundos.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.