一、普通同步方式
最简单和基础的调用方式，
@Test
public void test1Normal() {
Jedis jedis = new Jedis("localhost");
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String result = jedis.set("n" + i, "n" + i);
}
long end = System.currentTimeMillis();
System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");
jedis.disconnect();
}
很简单吧，每次set之后都可以返回结果，标记是否成功。
二、事务方式(Transactions)
redis的事务很简单，他主要目的是保障，一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。
看下面例子：
@Test
public void test2Trans() {
Jedis jedis = new Jedis("localhost");
long start = System.currentTimeMillis();
Transaction tx = jedis.multi();
for (int i = 0; i < 100000; i++) {
tx.set("t" + i, "t" + i);
}
List<Object> results = tx.exec();
long end = System.currentTimeMillis();
System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
jedis.disconnect();
}
我们调用jedis.watch(…)方法来监控key，如果调用后key值发生变化，则整个事务会执行失败。另外，事务中某个操作失败，并不会回滚其他操作。这一点需要注意。还有，我们可以使用discard()方法来取消事务。
三、管道(Pipelining)
有时，我们需要采用异步方式，一次发送多个指令，不同步等待其返回结果。这样可以取得非常好的执行效率。这就是管道，调用方法如下：
@Test
public void test3Pipelined() {
Jedis jedis = new Jedis("localhost");
Pipeline pipeline = jedis.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("p" + i, "p" + i);
}
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
jedis.disconnect();
}
四、管道中调用事务
就Jedis提供的方法而言，是可以做到在管道中使用事务，其代码如下：
@Test
public void test4combPipelineTrans() {
jedis = new Jedis("localhost");
long start = System.currentTimeMillis();
Pipeline pipeline = jedis.pipelined();
pipeline.multi();
for (int i = 0; i < 100000; i++) {
pipeline.set("" + i, "" + i);
}
pipeline.exec();
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");
jedis.disconnect();
}
但是经测试（见本文后续部分），发现其效率和单独使用事务差不多，甚至还略微差点。
五、分布式直连同步调用
@Test
public void test5shardNormal() {
List<JedisShardInfo> shards = Arrays.asList(
new JedisShardInfo("localhost",6379),
new JedisShardInfo("localhost",6380));
ShardedJedis sharding = new ShardedJedis(shards);
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String result = sharding.set("sn" + i, "n" + i);
}
long end = System.currentTimeMillis();
System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");
sharding.disconnect();
}
这个是分布式直接连接，并且是同步调用，每步执行都返回执行结果。类似地，还有异步管道调用。
六、分布式直连异步调用
@Test
public void test6shardpipelined() {
List<JedisShardInfo> shards = Arrays.asList(
new JedisShardInfo("localhost",6379),
new JedisShardInfo("localhost",6380));
ShardedJedis sharding = new ShardedJedis(shards);
ShardedJedisPipeline pipeline = sharding.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("sp" + i, "p" + i);
}
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");
sharding.disconnect();
}
七、分布式连接池同步调用
如果，你的分布式调用代码是运行在线程中，那么上面两个直连调用方式就不合适了，因为直连方式是非线程安全的，这个时候，你就必须选择连接池调用。
@Test
public void test7shardSimplePool() {
List<JedisShardInfo> shards = Arrays.asList(
new JedisShardInfo("localhost",6379),
new JedisShardInfo("localhost",6380));
ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
ShardedJedis one = pool.getResource();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String result = one.set("spn" + i, "n" + i);
}
long end = System.currentTimeMillis();
pool.returnResource(one);
System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");
pool.destroy();
}
上面是同步方式，当然还有异步方式。
八、分布式连接池异步调用
@Test
public void test8shardPipelinedPool() {
List<JedisShardInfo> shards = Arrays.asList(
new JedisShardInfo("localhost",6379),
new JedisShardInfo("localhost",6380));
ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
ShardedJedis one = pool.getResource();
ShardedJedisPipeline pipeline = one.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("sppn" + i, "n" + i);
}
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
pool.returnResource(one);
System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
pool.destroy();
}
九、需要注意的地方
-
事务和管道都是异步模式。在事务和管道中不能同步查询结果。比如下面两个调用，都是不允许的：
Transaction tx = jedis.multi(); for (int i = 0; i < 100000; i++) { tx.set("t" + i, "t" + i); } System.out.println(tx.get("t1000").get()); //不允许 List<Object> results = tx.exec(); … … Pipeline pipeline = jedis.pipelined(); long start = System.currentTimeMillis(); for (int i = 0; i < 100000; i++) { pipeline.set("p" + i, "p" + i); } System.out.println(pipeline.get("p1000").get()); //不允许 List<Object> results = pipeline.syncAndReturnAll(); -
事务和管道都是异步的，个人感觉，在管道中再进行事务调用，没有必要，不如直接进行事务模式。
-
分布式中，连接池的性能比直连的性能略好(见后续测试部分)。
-
分布式调用中不支持事务。
因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，所以，没法进行事务。
十、测试
运行上面的代码，进行测试，其结果如下：
Simple SET: 5.227 seconds Transaction SET: 0.5 seconds Pipelined SET: 0.353 seconds Pipelined transaction: 0.509 seconds Simple@Sharing SET: 5.289 seconds Pipelined@Sharing SET: 0.348 seconds Simple@Pool SET: 5.039 seconds Pipelined@Pool SET: 0.401 seconds
另外，经测试分布式中用到的机器越多，调用会越慢。上面是2片，下面是5片：
Simple@Sharing SET: 5.494 seconds Pipelined@Sharing SET: 0.51 seconds Simple@Pool SET: 5.223 seconds Pipelined@Pool SET: 0.518 seconds
下面是10片：
Simple@Sharing SET: 5.9 seconds Pipelined@Sharing SET: 0.794 seconds Simple@Pool SET: 5.624 seconds Pipelined@Pool SET: 0.762 seconds
下面是100片：
Simple@Sharing SET: 14.055 seconds Pipelined@Sharing SET: 8.185 seconds Simple@Pool SET: 13.29 seconds Pipelined@Pool SET: 7.767 seconds
分布式中，连接池方式调用不但线程安全外，根据上面的测试数据，也可以看出连接池比直连的效率更好。
十一、完整的测试代码
package com.example.nosqlclient;
import java.util.Arrays;
import java.util.List;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPipeline;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.jedis.Transaction;
import org.junit.FixMethodOrder;
import org.junit.runners.MethodSorters;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class TestJedis {
private static Jedis jedis;
private static ShardedJedis sharding;
private static ShardedJedisPool pool;
@BeforeClass
public static void setUpBeforeClass() throws Exception {
List<JedisShardInfo> shards = Arrays.asList(
new JedisShardInfo("localhost",6379),
new JedisShardInfo("localhost",6379)); //使用相同的ip:port,仅作测试
jedis = new Jedis("localhost");
sharding = new ShardedJedis(shards);
pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
jedis.disconnect();
sharding.disconnect();
pool.destroy();
}
@Test
public void test1Normal() {
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String result = jedis.set("n" + i, "n" + i);
}
long end = System.currentTimeMillis();
System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");
}
@Test
public void test2Trans() {
long start = System.currentTimeMillis();
Transaction tx = jedis.multi();
for (int i = 0; i < 100000; i++) {
tx.set("t" + i, "t" + i);
}
//System.out.println(tx.get("t1000").get());
List<Object> results = tx.exec();
long end = System.currentTimeMillis();
System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
}
@Test
public void test3Pipelined() {
Pipeline pipeline = jedis.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("p" + i, "p" + i);
}
//System.out.println(pipeline.get("p1000").get());
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
}
@Test
public void test4combPipelineTrans() {
long start = System.currentTimeMillis();
Pipeline pipeline = jedis.pipelined();
pipeline.multi();
for (int i = 0; i < 100000; i++) {
pipeline.set("" + i, "" + i);
}
pipeline.exec();
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");
}
@Test
public void test5shardNormal() {
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String result = sharding.set("sn" + i, "n" + i);
}
long end = System.currentTimeMillis();
System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");
}
@Test
public void test6shardpipelined() {
ShardedJedisPipeline pipeline = sharding.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("sp" + i, "p" + i);
}
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");
}
@Test
public void test7shardSimplePool() {
ShardedJedis one = pool.getResource();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String result = one.set("spn" + i, "n" + i);
}
long end = System.currentTimeMillis();
pool.returnResource(one);
System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");
}
@Test
public void test8shardPipelinedPool() {
ShardedJedis one = pool.getResource();
ShardedJedisPipeline pipeline = one.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("sppn" + i, "n" + i);
}
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
pool.returnResource(one);
System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
}
}
相关推荐
本示例将详细讲解如何在C#中调用Redis进行数据操作。 首先，你需要安装`StackExchange.Redis`库，这是一个广受欢迎的C# Redis客户端。通过NuGet包管理器或命令行工具（如dotnet CLI）可以轻松安装。在Visual Studio...
`Redis调用操作类.php`可能包含了上述所有或部分功能，通过面向对象的方式进行了封装，例如定义了如`connect()`、`set()`、`get()`等方法，使得开发者能够更方便地调用。类中可能还包含了一些便利的功能，如错误处理...
《custom-redis：简化Redis调用与分布式支持的利器》 在现代的互联网应用中，Redis作为一款高性能的键值存储系统，被广泛用于缓存、消息队列、计数器等多种场景。为了更好地整合Redis的功能，并简化开发过程，`...
本文将深入探讨`REDIS_redis的工具包`，特别是`redisinlabview`和`labviewredis`，以及如何在LabVIEW中调用Redis的相关知识点。 ### RedisinLabVIEW `redisinlabview`是为LabVIEW设计的一个工具包，它提供了一系列...
对于C#中的Redis调用，主要依赖于第三方库，如StackExchange.Redis，它是.NET平台最受欢迎的Redis客户端之一。以下是如何使用StackExchange.Redis进行C#调用的基本步骤： 1. **安装库**：在你的项目中，通过NuGet包...
kettle5.4调用redis测试脚本 Redis作为一个开源免费，高性能的kv数据库，官方称号称能够达到10w+的读写速度；本文讲解Redis如何与kettle结合，看看能够擦出什么火花~~ Redis版本：3.2.100 Kett版本：5.4
5. **持久化**：Redis提供两种持久化方式：RDB（快照）和AOF（Append Only File）。RDB在指定时间间隔保存当前数据库状态，而AOF记录所有写操作日志，确保数据在系统崩溃后能够恢复。 6. **主从复制**：为了提高...
然而，不恰当的Redis调用方式可能导致性能问题，尤其是在高并发场景下。本文通过一个实际的Node.js项目示例，讲解了如何优化Redis调用的几种方法。 首先，原始的错误做法是在for循环中使用await逐个获取Redis键值，...
本文将详细讲解如何使用Java调用Redis，并探讨相关知识点。 一、Jedis库的使用 1. 添加依赖：在你的`pom.xml`文件中添加Jedis的Maven依赖： ```xml <groupId>redis.clients <artifactId>jedis <version>3.7.0 ...
在本文中，我们将深入探讨如何在C#中利用ServiceStack.Redis库来调用Redis数据库，以实现各种数据类型的存储和操作。首先，我们需要确保我们已经在Visual Studio 2017中配置好了项目环境。 1. **环境配置** 在VS...
而Java作为广泛使用的后端开发语言，提供了多种方式来与Redis进行交互。本篇将通过一个简单的Java调用Redis的Demo来探讨如何在Java应用中操作Redis。 首先，我们需要在项目中引入Jedis库，这是一个Java客户端，用于...
在“redis C# 调用Demo”中，我们将探讨如何使用C#和StackExchange.Redis库来实现Redis的基本操作。首先，确保已经在项目中引用了StackExchange.Redis NuGet包，这是连接和操作Redis的关键。 1. **连接Redis服务器*...
6. `Controller.java`：控制器层，处理HTTP请求，调用`Service`实现功能。 以上就是基于SpringBoot集成RabbitMQ和Redis的基本概念和应用场景，通过这样的组合，我们可以构建出高并发、高可用、响应快速的应用系统。...
在Windows环境下调用Redis实例是一项常见的任务，尤其是在开发和测试阶段。Redis是一个开源的、基于键值对的数据存储系统，广泛用于缓存、消息队列和数据库等方面。本指南将详细讲解如何在Windows上利用Visual ...
在本项目中，我们主要探讨如何利用ASP.NET Core 3.1框架和StackExchange.Redis库来构建一个基于Redis的Web客户端。Redis是一个高性能的键值数据存储系统，常用于缓存、消息队列以及分布式计算等多种场景。在这个案例...
利用php语言调用redis,无需安装php-redis扩展。调用方式： $redis = new Phpredis(); $redis->client->select(7); $res=$redis->client->get("key");
总结起来，使用Hiredis在C++中封装Redis调用主要包括以下步骤： 1. 创建`redisContext`连接。 2. 使用`redisCommand`发送Redis命令。 3. 检查`redisReply`并处理响应。 4. 在适当的时候释放资源。 通过封装这些操作...
谈下你对 Redis 的了解？ 1）Redis是一种基于键值对的NoSQL数据库（非关系型数据库）；是一个key-value存储系统 2）高性能、可靠性 Redis将数据存储在内存中，读写性能高；Redis提供了 RDB和AOF持久化，可将内存...
这个工具包提供了一种纯Java的调用方式，使得开发者无需深入理解Redis命令，也能便捷地在应用程序中集成分布式锁功能。它不仅适用于传统的Spring工程，还为Spring Boot应用提供了Starter，使得在微服务架构中使用...