Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式)介绍

最新推荐文章于 2023-09-20 20:39:34 发布
最新推荐文章于 2023-09-20 20:39:34 发布
阅读量332 收藏
点赞数
分类专栏： redis
jedis是一个著名的key-value存储系统，而作为其官方推荐的java版客户端jedis也非常强大和稳定，支持事务、管道及有jedis自身实现的分布式。

在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比：

一、普通同步方式

最简单和基础的调用方式，

?
1
2
3
4
5
6
7
8
9
10
11
@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的命令。

看下面例子：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
@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)

有时，我们需要采用异步方式，一次发送多个指令，不同步等待其返回结果。这样可以取得非常好的执行效率。这就是管道，调用方法如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
@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提供的方法而言，是可以做到在管道中使用事务，其代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@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();
}

但是经测试（见本文后续部分），发现其效率和单独使用事务差不多，甚至还略微差点。

五、分布式直连同步调用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@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();
}

这个是分布式直接连接，并且是同步调用，每步执行都返回执行结果。类似地，还有异步管道调用。

六、分布式直连异步调用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@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();
}

七、分布式连接池同步调用

如果，你的分布式调用代码是运行在线程中，那么上面两个直连调用方式就不合适了，因为直连方式是非线程安全的，这个时候，你就必须选择连接池调用。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@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();
}

上面是同步方式，当然还有异步方式。

八、分布式连接池异步调用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@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();
}

九、需要注意的地方

  1. 事务和管道都是异步模式。在事务和管道中不能同步查询结果。比如下面两个调用，都是不允许的：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
      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();

  2. 事务和管道都是异步的，个人感觉，在管道中再进行事务调用，没有必要，不如直接进行事务模式。

  3. 分布式中，连接池的性能比直连的性能略好(见后续测试部分)。

  4. 分布式调用中不支持事务。

    因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，所以，没法进行事务。

十、测试

运行上面的代码，进行测试，其结果如下：

?
1
2
3
4
5
6
7
8
9
10
11
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片：

?
1
2
3
4
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片：

?
1
2
3
4
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片：

?
1
2
3
4
Simple @Sharing  SET:  14.055  seconds
Pipelined @Sharing  SET:  8.185  seconds
Simple @Pool  SET:  13.29  seconds
Pipelined @Pool  SET:  7.767  seconds

分布式中，连接池方式调用不但线程安全外，根据上面的测试数据，也可以看出连接池比直连的效率更好。

十一、完整的测试代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
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" );
     }
}
GavinYCF
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jedisRedis的Java客户端
08-08
Jedis是Redis的Java客户端，它提供了一个丰富的API来操作Redis数据存储系统。Redis是一个高性能的键值数据库，常用于缓存、消息中间件以及数据结构服务器等场景。Jedis作为Java开发者与Redis交互的主要工具，使得在...
Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式…)介绍
iteye_5347的博客
10-30 496
redis是一个著名的key-value存储系统，而作为其官方推荐的java版客户端jedis也非常强大和稳定，支持事务、管道及有jedis自身实现的分布式。 在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比： 一、普通同步方式 最简单和基础的调用方式， @Test public void test1Normal() { Jedis jedis = n...
手写Redis客户端-实现自己的Jedis
ljheee的博客
01-07 722
手写Redis客户端-实现自己的Jedis 上一篇，我们详细研究了Redis底层使用的协议——RESP(REdis Serialization Protocol)，这篇我们在基于理解了RESP原理的基础上，手写一个Redis客户端，实现一个自己的Jedis（mini版）。 还没了解Redis底层RESP协议 的同学，可以先移步Redis底层协议RESP详解，对RESP做一个大致的了解。 Redis...
Redis的调用
wuxiaojun的专栏
07-25 1638
简单说下redis在java中如何调用： 1、首先要安装redis客户端，可以自行去redis官网下载（网址：redis.io）     下载后得到如下文件： 对应5个可执行文件。 点击redis-server.exe，启动redis服务.可以看到如下： 然后可以在进入redis-cli.exe，进行测试，此时保持之前的窗口不要关闭，否则服务连接失败；
使用java操作redis
热门推荐
yzq102873的博客
10-26 1万+
java操作redis
Java基于redis实现分布式锁代码实例
08-19
Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...
redis中使用java脚本实现分布式锁
09-10
在Redis中，我们可以使用Java脚本或者Lua脚本来实现分布式锁。本文将深入探讨这两种方法，以及它们如何帮助我们应对分布式环境中的并发问题。 首先，Redis作为一款内存数据库，因其高性能和丰富的数据结构，常被...
jedis.jar java调用Redis及Redis安装使用
09-03
Jedis是Redis官方推荐的Java客户端，提供了丰富的API来操作Redis。 1. **引入依赖**：在项目中，需要添加`jedis-2.1.0.jar`作为依赖。对于Maven项目，可以在pom.xml文件中添加如下依赖： ```xml <groupId>redis...
Redis框架Jedis及Redisson对比解析
08-18
Redisson实现了分布式和可扩展的Java数据结构，和Jedis相比，功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。 ### 编程模型 Jedis中的方法调用是比较底层的暴露的Redis的API，也即...
Redis的简单使用
chat_bot的博客
10-24 1510
redis是单线程的。NOSQL的非关系型数据库，是以键值对的形式在内存中存储数据。数据吞吐量比较大，在高并发情况下进行数据的查询效率更高。由于存储在内存中，数据有可能丢失。redis一般用于缓存数据库中的数据，提升查询效率。
java 调用 Redis 的八种方式：普通、事务、管道、管道调用事务、分布式直连同步(异步)调用、分布式连接池同步(异步)调用
XHChen的博客
04-21 611
开始前需要准备两个jar包，当然运行前还需要开启redis服务（redis-server.exe redis.windows.conf）就不详细说了。 Apache Commons Pool Jedis 一、普通同步 基础的调用方式，每次set之后都可以返回结果，标记是否成功。 @Test public void NormalSyncTest() { Jedis jedis =...
Java中使用Redis（即学即用）
心有谦谦结
11-01 7129
一、为什么需要用Redis？ Redis（Remote Dictionary Server），一个基于内存的高性能key-value数据库。针对关系型数据库性能瓶颈来设计的，处理关系型数据库不擅长做的业务场景。Redis 多用于项目的高速缓存，可以让项目性能更好。 Redis的应用场景 二、安装Redis 1、下面提供其中一个版本的Redis： 链接：https://pan.baidu.com/s/1Z3QRpdMzUyPh8ODZJDgGEA 提取码：j8vl 复制这段内容后打开百度...
【如何使用jedis】
展翅的雄鹰
03-25 514
前言:今天咱们主要来讲jedis连接redis,主要讲两个方面,一是从连接单机版方面,另一个是从连接集群版方面来进行分享,感谢大家的阅读.核心1. 连接单机版第一步：创建一个Jedis对象。需要指定服务端的ip及端口。第二步：使用Jedis对象操作数据库，每个redis命令对应一个方法。第三步：打印结果。第四步：关闭Jedis@Test public void testJedis()...
如何正确使用redis
weixin_42272869的博客
05-16 5630
如何正确使用redis 1. 概述 简单来说，Redis就是一个数据结构存储器，可以用作数据库、缓存和消息中间件，它和传统数据库主要有两点不同： 它是Key-Value型数据库，不是关系型数据库，所有数据以Key-Value的形式存在服务器的内存中，其中Value可以是多种数据结构：字符串(String), 哈希(hashes), 列表(list), 集合(sets) 和有序集合(sorted sets)等类型； 它所有运行时数据都存在内存中，总所周知，内存的存取效率比磁盘要高不止一个数量级，Redis的
Redis8种访问方式
u010724583的专栏
05-29 1030
 package com.gqshao.redis.connection; import org.junit.Test; import redis.clients.jedis.*; import java.util.Arrays; import java.util.List; /**  * Redis的Java客户端Jedis的八种调用方式  */ public class
python调用redis 五大基本类型
LoadingCreate的博客
03-22 412
先学习一下redis的入门，了解redis的配置和部分语法。
Redis快速入门及在Java中使用Redis
最新发布
程序猿追的博客
09-20 3万+
Redis是用C语言开发的一个开源的高性能键值对(key-value)数据库，官方提供的数据是可以达到100000+的QPS（每秒内查询次数）。它存储的value类型比较丰富，也被称为结构化的NoSql（NoSql（Not Only SQL），不仅仅是SQL，泛指非关系型数据库。NoSql数据库并不是要取代关系型数据库，而是关系型数据库的补充。 ）数据库。
Java操作Redis以及Redis线程池的用法
金鳞踏雨
06-26 1916
在Redis官网中提供了很多语言的客户端：Redis官网所以我们大致是要了解3种客户端 Jedis、lettuce、Redisson其中Spring帮我们做了整合，将Jedis与lettuce进行了封装成了它特有的Spring Data Redis至于Redisson是用在分布式的场景中，在学习分布式锁的时候小伙伴可以自行去了解一下，这里不做赘述。 建立连接、编写测试方法、释放资源 注意： 在Junit5中使用 @BeforeEach注解替代了 在Junit4的@Before。表示
java redis分布式锁
08-02
分布式锁是在分布式系统中用于解决并发访问共享资源的问题的一种机制。在Java中，可以使用Redis实现分布式锁。有几种常见的实现方式。 一种方式是使用RedisTemplate来操作Redis，通过调用opsForValue().setIfAbsent()方法来尝试获取锁。如果返回true，则表示获取锁成功，可以执行业务逻辑；如果返回false，则表示获取锁失败，需要等待一段时间后重试。在执行完业务逻辑后，需要调用redisTemplate.delete()方法来释放锁。这种方式需要注意的是，获取锁和释放锁的操作需要在同一个Redis连接中进行，以保证原子性。[1] 另一种方式是直接使用Jedis来操作Redis。通过调用setnx()方法来尝试获取锁，如果返回1，则表示获取锁成功，可以执行业务逻辑；如果返回0，则表示获取锁失败，需要等待一段时间后重试。在执行完业务逻辑后，需要调用jedis.del()方法来释放锁。这种方式也需要注意获取锁和释放锁的操作需要在同一个Redis连接中进行，以保证原子性。[2] 需要注意的是，分布式锁的实现需要考虑到并发情况下的线程安全性和可靠性。在使用分布式锁时，还需要考虑锁的超时时间和重试机制，以防止死锁和长时间等待的情况发生。 总结起来，Java通过Redis实现分布式锁的方式有多种，可以使用RedisTemplate或者直接使用Jedis来操作Redis。具体选择哪种方式取决于项目的需求和技术栈的选择。[1][2][3]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值