redis linux 安装及jedis连接测试

时间:2022-08-12 17:29:25

一。安装配置

1:下载redis
下载地址 http://code.google.com/p/redis/downloads/list
推荐下载redis-1.2.6.tar.gz,之前这个版本同事已经有成功安装运行的经验,redis-2.0.4.tar.gz 这个版本我安装后无法操作缓存数据,具体原因后续再说

2:安装redis
下载后解压 tar zxvf redis-1.2.6.tar.gz 到任意目录,例如/usr/local/redis-1.2.6

解压后,进入redis目录
    cd /usr/local/redis-1.2.6 
    make 

拷贝文件
cp redis.conf /etc/ 这个文件时redis启动的配置文件
cp redis-benchmark redis-cli redis-server /usr/bin/ #这个倒是很有用,这样就不用再执行时加上./了,而且可以在任何地方执行

设置内存分配策略(可选,根据服务器的实际情况进行设置)
/proc/sys/vm/overcommit_memory
可选值:0、1、2。
0, 表示内核将检查是否有足够的可用内存供应用进程使用;如果有足够的可用内存,内存申请允许;否则,内存申请失败,并把错误返回给应用进程。
1, 表示内核允许分配所有的物理内存,而不管当前的内存状态如何。
2, 表示内核允许分配超过所有物理内存和交换空间总和的内存

值得注意的一点是,redis在dump数据的时候,会fork出一个子进程,理论上child进程所占用的内存和parent是一样的,比如parent占用的内存为8G,这个时候也要同样分配8G的内存给child,如果内存无法负担,往往会造成redis服务器的down机或者IO负载过高,效率下降。所以这里比较优化的内存分配策略应该设置为 1(表示内核允许分配所有的物理内存,而不管当前的内存状态如何)

开启redis端口,修改防火墙配置文件
    vi /etc/sysconfig/iptables 

加入端口配置
    -A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 6379 -j ACCEPT 

重新加载规则
    service iptables restart  

3:启动redis服务
    [root@Architect redis-1.2.6]# pwd 
    /usr/local/redis-1.2.6 
    [root@Architect redis-1.2.6]# redis-server /etc/redis.conf 

查看进程,确认redis已经启动

    [root@Architect redis-1.2.6]# ps -ef | grep redis 
    root       401 29222  0 18:06 pts/3    00:00:00 grep redis 
    root     29258     1  0 16:23 ?        00:00:00 redis-server /etc/redis.conf 

如果这里启动redis服务失败,一般情况下是因为redis.conf文件有问题,建议检查或找个可用的配置文件进行覆盖,避免少走弯路,这里建议,修改redis.conf,设置redis进程为后台守护进程

    # By default Redis does not run as a daemon. Use 'yes' if you need it. 
    # Note that Redis will write a pid file in /var/run/redis.pid when daemonized. 
    daemonize yes 

4:测试redis
    [root@Architect redis-1.2.6]# redis-cli 
    redis> set name songbin 
    OK 
    redis> get name  
    "songbin" 

5:关闭redis服务
    redis-cli shutdown 

redis服务关闭后,缓存数据会自动dump到硬盘上,硬盘地址为redis.conf中的配置项dbfilename dump.rdb所设定
强制备份数据到磁盘,使用如下命令

    redis-cli save 或者 redis-cli -p 6380 save(指定端口)

 

二.jedis连接(maven项目)

<spring.redis.version>1.5.2.RELEASE</spring.redis.version>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>${jedis.version}</version>
</dependency>

 

redis.properties

redis.pool.maxActive= 1000
redis.pool.maxIdle= 20
redis.pool.maxWait= 3000
redis.ip= 192.168.1.110
redis.port= 6379

  1 package redis;
2
3 import net.sf.json.JSONObject;
4 import redis.clients.jedis.Jedis;
5 import redis.clients.jedis.JedisPool;
6 import redis.clients.jedis.JedisPoolConfig;
7
8 import java.util.*;
9
10 /**
11 * Created by Administrator on 2016/6/14.
12 */
13
14 public class RedisClient {
15
16 public static JedisPool jedisPool; // 池化管理jedis链接池
17
18 static {
19
20 //读取相关的配置
21 ResourceBundle resourceBundle = ResourceBundle.getBundle("redis");
22 int maxActive = Integer.parseInt(resourceBundle.getString("redis.pool.maxActive"));
23 int maxIdle = Integer.parseInt(resourceBundle.getString("redis.pool.maxIdle"));
24 int maxWait = Integer.parseInt(resourceBundle.getString("redis.pool.maxWait"));
25
26 String ip = resourceBundle.getString("redis.ip");
27 int port = Integer.parseInt(resourceBundle.getString("redis.port"));
28
29 JedisPoolConfig config = new JedisPoolConfig();
30 //设置最大连接数
31 config.setMaxTotal(maxActive);
32 //设置最大空闲数
33 config.setMaxIdle(maxIdle);
34 //设置超时时间
35 config.setMaxWaitMillis(maxWait);
36 //初始化连接池
37 jedisPool = new JedisPool(config, ip, port);
38 }
39
40 /**
41 * 向缓存中设置字符串内容
42 *
43 * @param key key
44 * @param value value
45 * @return
46 * @throws Exception
47 */
48 public static boolean set(String key, String value) throws Exception {
49 Jedis jedis = null;
50 try {
51 jedis = jedisPool.getResource();
52 jedis.set(key, value);
53 return true;
54 } catch (Exception e) {
55 e.printStackTrace();
56 return false;
57 } finally {
58 jedisPool.returnResource(jedis);
59 }
60 }
61
62 /**
63 * 向缓存中设置对象
64 *
65 * @param key
66 * @param value
67 * @return
68 */
69 public static boolean set(String key, Object value) {
70 Jedis jedis = null;
71 try {
72 jedis = jedisPool.getResource();
73 jedis.set(key.getBytes(), SerializeUtil.serialize(value));
74 return true;
75 } catch (Exception e) {
76 e.printStackTrace();
77 return false;
78 } finally {
79 jedisPool.returnResource(jedis);
80 }
81 }
82
83 /**
84 * 删除缓存中得对象,根据key
85 *
86 * @param key
87 * @return
88 */
89 public static boolean del(String key) {
90 Jedis jedis = null;
91 try {
92 jedis = jedisPool.getResource();
93 jedis.del(key);
94 return true;
95 } catch (Exception e) {
96 e.printStackTrace();
97 return false;
98 } finally {
99 jedisPool.returnResource(jedis);
100 }
101 }
102
103 /**
104 * 根据key 获取内容
105 *
106 * @param key
107 * @return
108 */
109 public static Object get(String key) {
110
111 Jedis jedis = null;
112 try {
113 jedis = jedisPool.getResource();
114 byte[] value = jedis.get(key.getBytes());
115 return SerializeUtil.unserialize(value);
116 } catch (Exception e) {
117 e.printStackTrace();
118 return false;
119 } finally {
120 jedisPool.returnResource(jedis);
121 }
122 }
123
124 public static void main(String[] args) throws Exception {
125 // //测试存储字符串
126 // RedisClient.set("hello", "world");
127 // System.out.println(RedisClient.get("hello"));
128 // //测试存储对象
129 // People people = new People();// 存放对象时 必须实现序列化
130 // people.setName("wamhf");
131 // people.setAge(26);
132 // RedisClient.set("name1", people);
133 // People p = (People) RedisClient.get("name1");
134 // System.out.println(p.getAge() + "-------" + p.getName());
135 // //测试存储List
136 // List list = new ArrayList();
137 // list.add("111");
138 // list.add("222");
139 // list.add("333");
140 // RedisClient.set("list", list);
141 // List list1 = (List) RedisClient.get("list");
142 // for (Object o : list1) {
143 // System.out.println(o.toString());
144 // }
145 // //测试存储Set
146 // Set set = new HashSet<>();
147 // set.add("a");
148 // set.add(1);
149 // RedisClient.set("set", set);
150 // Set s = (Set) RedisClient.get("set");
151 // for (Object o : s) {
152 // System.out.println(o.toString());
153 // }
154 // System.out.println("---------------------验证set去重---------------------");
155 // Set set1 = new HashSet<>();
156 // set1.add("a");
157 // set1.add(1);
158 // RedisClient.set("set", set1);
159 // Set s1 = (Set) RedisClient.get("set");
160 // for (Object o : s1) {
161 // System.out.println(o.toString());
162 // }
163
164 RedisClient redisClient = new RedisClient();
165 redisClient.test();
166 }
167
168 public void test() {
169 Jedis redis = jedisPool.getResource();
170 /* ----------------------------------------------------------------------------------------------------------- */
171 // KEY操作
172
173 //KEYS
174 Set keys = redis.keys("*");//列出所有的key,查找特定的key如:redis.keys("foo")
175 Iterator t1 = keys.iterator();
176 while (t1.hasNext()) {
177 Object obj1 = t1.next();
178 System.out.println(obj1);
179 }
180
181 //DEL 移除给定的一个或多个key。如果key不存在,则忽略该命令。
182 // redis.del("set");
183
184 //TTL 返回给定key的剩余生存时间(time to live)(以秒为单位)
185 System.out.println(redis.ttl("hello"));
186
187 //PERSIST key 移除给定key的生存时间。
188 redis.persist("foo");
189
190 //EXISTS 检查给定key是否存在。
191 redis.exists("foo");
192
193 //MOVE key db 将当前数据库(默认为0)的key移动到给定的数据库db当中。如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定key,或者key不存在于当前数据库,那么MOVE没有任何效果。
194 redis.move("foo", 1);//将foo这个key,移动到数据库1
195
196 //RENAME key newkey 将key改名为newkey。当key和newkey相同或者key不存在时,返回一个错误。当newkey已经存在时,RENAME命令将覆盖旧值。
197 redis.rename("foo", "foonew");
198
199 //TYPE key 返回key所储存的值的类型。
200 System.out.println(redis.type("foo"));//none(key不存在),string(字符串),list(列表),set(集合),zset(有序集),hash(哈希表)
201
202 //EXPIRE key seconds 为给定key设置生存时间。当key过期时,它会被自动删除。
203 redis.expire("foo", 5);//5秒过期
204 //EXPIREAT EXPIREAT的作用和EXPIRE一样,都用于为key设置生存时间。不同在于EXPIREAT命令接受的时间参数是UNIX时间戳(unix timestamp)。
205
206 //一般SORT用法 最简单的SORT使用方法是SORT key。
207 redis.lpush("sort", "1");
208 redis.lpush("sort", "4");
209 redis.lpush("sort", "6");
210 redis.lpush("sort", "3");
211 redis.lpush("sort", "0");
212
213 List list = redis.sort("sort");//默认是升序
214 for (int i = 0; i < list.size(); i++) {
215 System.out.println(list.get(i));
216 }
217
218
219 /* ----------------------------------------------------------------------------------------------------------- */
220 // STRING 操作
221
222 //SET key value将字符串值value关联到key。
223 redis.set("name", "wangjun1");
224 redis.set("id", "123456");
225 redis.set("address", "guangzhou");
226
227 //SETEX key seconds value将值value关联到key,并将key的生存时间设为seconds(以秒为单位)。
228 redis.setex("foo", 5, "haha");
229
230 //MSET key value [key value ...]同时设置一个或多个key-value对。
231 redis.mset("haha", "111", "xixi", "222");
232
233 //redis.flushAll();清空所有的key
234 System.out.println(redis.dbSize());//dbSize是多少个key的个数
235
236 //APPEND key value如果key已经存在并且是一个字符串,APPEND命令将value追加到key原来的值之后。
237 redis.append("foo", "00");//如果key已经存在并且是一个字符串,APPEND命令将value追加到key原来的值之后。
238
239 //GET key 返回key所关联的字符串值
240 redis.get("foo");
241
242 //MGET key [key ...] 返回所有(一个或多个)给定key的值
243 List list1 = redis.mget("haha", "xixi");
244 for (int i = 0; i < list1.size(); i++) {
245 System.out.println(list1.get(i));
246 }
247
248 //DECR key将key中储存的数字值减一。
249 //DECRBY key decrement将key所储存的值减去减量decrement。
250 //INCR key 将key中储存的数字值增一。
251 //INCRBY key increment 将key所储存的值加上增量increment。
252
253
254 /* ----------------------------------------------------------------------------------------------------------- */
255 // Hash 操作
256
257 //HSET key field value将哈希表key中的域field的值设为value。
258 redis.hset("website", "google", "www.google.cn");
259 redis.hset("website", "baidu", "www.baidu.com");
260 redis.hset("website", "sina", "www.sina.com");
261
262 //HMSET key field value [field value ...] 同时将多个field - value(域-值)对设置到哈希表key中。
263 Map map = new HashMap();
264 map.put("cardid", "123456");
265 map.put("username", "jzkangta");
266 redis.hmset("hash", map);
267
268 //HGET key field返回哈希表key中给定域field的值。
269 System.out.println(redis.hget("hash", "username"));
270
271 //HMGET key field [field ...]返回哈希表key中,一个或多个给定域的值。
272 List list2 = redis.hmget("website", "google", "baidu", "sina");
273 for (int i = 0; i < list2.size(); i++) {
274 System.out.println(list2.get(i));
275 }
276
277 //HGETALL key返回哈希表key中,所有的域和值。
278 Map<String, String> map1 = redis.hgetAll("hash");
279 for (Map.Entry entry : map1.entrySet()) {
280 System.out.print(entry.getKey() + ":" + entry.getValue() + "\t");
281 }
282
283 //HDEL key field [field ...]删除哈希表key中的一个或多个指定域。
284 //HLEN key 返回哈希表key中域的数量。
285 //HEXISTS key field查看哈希表key中,给定域field是否存在。
286 //HINCRBY key field increment为哈希表key中的域field的值加上增量increment。
287 //HKEYS key返回哈希表key中的所有域。
288 //HVALS key返回哈希表key中的所有值。
289
290
291 /* ----------------------------------------------------------------------------------------------------------- */
292 // LIST 操作
293 //LPUSH key value [value ...]将值value插入到列表key的表头。
294 redis.lpush("list", "abc");
295 redis.lpush("list", "xzc");
296 redis.lpush("list", "erf");
297 redis.lpush("list", "bnh");
298
299 //LRANGE key start stop返回列表key中指定区间内的元素,区间以偏移量start和stop指定。下标(index)参数start和stop都以0为底,也就是说,以0表示列表的第一个元素,以1表示列表的第二个元素,以此类推。你也可以使用负数下标,以-1表示列表的最后一个元素,-2表示列表的倒数第二个元素,以此类推。
300 List list3 = redis.lrange("list", 0, -1);
301 for (int i = 0; i < list3.size(); i++) {
302 System.out.println(list3.get(i));
303 }
304
305 //LLEN key返回列表key的长度。
306 //LREM key count value根据参数count的值,移除列表中与参数value相等的元素。
307
308 /* ----------------------------------------------------------------------------------------------------------- */
309 // SET 操作
310 //SADD key member [member ...]将member元素加入到集合key当中。
311 redis.sadd("testSet", "s1");
312 redis.sadd("testSet", "s2");
313 redis.sadd("testSet", "s3");
314 redis.sadd("testSet", "s4");
315 redis.sadd("testSet", "s5");
316
317 //SREM key member移除集合中的member元素。
318 redis.srem("testSet", "s5");
319
320 //SMEMBERS key返回集合key中的所有成员。
321 Set set = redis.smembers("testSet");
322 Iterator t2 = set.iterator();
323 while (t2.hasNext()) {
324 Object obj1 = t2.next();
325 System.out.println(obj1);
326 }
327
328 //SISMEMBER key member判断member元素是否是集合key的成员。是(true),否则(false)
329 System.out.println(redis.sismember("testSet", "s4"));
330
331 //SCARD key返回集合key的基数(集合中元素的数量)。
332 //SMOVE source destination member将member元素从source集合移动到destination集合。
333
334 //SINTER key [key ...]返回一个集合的全部成员,该集合是所有给定集合的交集。
335 //SINTERSTORE destination key [key ...]此命令等同于SINTER,但它将结果保存到destination集合,而不是简单地返回结果集
336 //SUNION key [key ...]返回一个集合的全部成员,该集合是所有给定集合的并集。
337 //SUNIONSTORE destination key [key ...]此命令等同于SUNION,但它将结果保存到destination集合,而不是简单地返回结果集。
338 //SDIFF key [key ...]返回一个集合的全部成员,该集合是所有给定集合的差集 。
339 //SDIFFSTORE destination key [key ...]此命令等同于SDIFF,但它将结果保存到destination集合,而不是简单地返回结果集。
340
341
342 }
343
344 }
 1 package redis;
2
3 import java.io.ByteArrayInputStream;
4 import java.io.ByteArrayOutputStream;
5 import java.io.ObjectInputStream;
6 import java.io.ObjectOutputStream;
7
8 /**
9 * Created by Administrator on 2016/6/14.
10 */
11 public class SerializeUtil {
12 public static byte[] serialize(Object object) {
13 ObjectOutputStream oos = null;
14 ByteArrayOutputStream baos = null;
15 try {
16 // 序列化
17 baos = new ByteArrayOutputStream();
18 oos = new ObjectOutputStream(baos);
19 oos.writeObject(object);
20 byte[] bytes = baos.toByteArray();
21 return bytes;
22 } catch (Exception e) {
23
24 }
25 return null;
26 }
27
28 public static Object unserialize(byte[] bytes) {
29 ByteArrayInputStream bais = null;
30 try {
31 // 反序列化
32 bais = new ByteArrayInputStream(bytes);
33 ObjectInputStream ois = new ObjectInputStream(bais);
34 return ois.readObject();
35 } catch (Exception e) {
36
37 }
38 return null;
39 }
40 }
package redis;

import java.io.Serializable;

/**
* Created by Administrator on 2016/6/14.
*/
public class People implements Serializable {
private String name;
private int age;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
}

 

三.redis 五种数据类型的使用场景 

String

1、String
常用命令:
除了get、set、incr、decr mget等操作外,Redis还提供了下面一些操作:
获取字符串长度
往字符串append内容
设置和获取字符串的某一段内容
设置及获取字符串的某一位(bit)
批量设置一系列字符串的内容

应用场景:
String是最常用的一种数据类型,普通的key/value存储都可以归为此类,value其实不仅是String,
也可以是数字:比如想知道什么时候*一个IP地址(访问超过几次)。INCRBY命令让这些变得很容易,通过原子递增保持计数。

实现方式:
m,decr等操作时会转成数值型进行计算,此时redisObject的encoding字段为int。


Hash

常用命令:
hget,hset,hgetall 等。
应用场景:
我们简单举个实例来描述下Hash的应用场景,比如我们要存储一个用户信息对象数据,包含以下信息:
用户ID,为查找的key,
存储的value用户对象包含姓名name,年龄age,生日birthday 等信息,
如果用普通的key/value结构来存储,主要有以下2种存储方式:
第一种方式将用户ID作为查找key,把其他信息封装成一个对象以序列化的方式存储,
如:set u001 "李三,18,20010101"
这种方式的缺点是,增加了序列化/反序列化的开销,并且在需要修改其中一项信息时,需要把整个对象取回,并且修改操作需要对并发进行保护,引入CAS等复杂问题。
第二种方法是这个用户信息对象有多少成员就存成多少个key-value对儿,用用户ID+对应属性的名称作为唯一标识来取得对应属性的值,
如:mset user:001:name "李三 "user:001:age18 user:001:birthday "20010101"
虽然省去了序列化开销和并发问题,但是用户ID为重复存储,如果存在大量这样的数据,内存浪费还是非常可观的。
那么Redis提供的Hash很好的解决了这个问题,Redis的Hash实际是内部存储的Value为一个HashMap,
并提供了直接存取这个Map成员的接口,
如:hmset user:001 name "李三" age 18 birthday "20010101"
也就是说,Key仍然是用户ID,value是一个Map,这个Map的key是成员的属性名,value是属性值,
这样对数据的修改和存取都可以直接通过其内部Map的Key(Redis里称内部Map的key为field), 也就是通过
key(用户ID) + field(属性标签) 操作对应属性数据了,既不需要重复存储数据,也不会带来序列化和并发修改控制的问题。很好的解决了问题。

这里同时需要注意,Redis提供了接口(hgetall)可以直接取到全部的属性数据,但是如果内部Map的成员很多,那么涉及到遍历整个内部Map的操作,由于Redis单线程模型的缘故,这个遍历操作可能会比较耗时,而另其它客户端的请求完全不响应,这点需要格外注意。
实现方式:
上面已经说到Redis Hash对应Value内部实际就是一个HashMap,实际这里会有2种不同实现,这个Hash的成员比较少时Redis为了节省内存会采用类似一维数组的方式来紧凑存储,而不会采用真正的HashMap结构,对应的value redisObject的encoding为zipmap,当成员数量增大时会自动转成真正的HashMap,此时encoding为ht。

List

常用命令:
lpush,rpush,lpop,rpop,lrange,BLPOP(阻塞版)等。

应用场景:
Redis list的应用场景非常多,也是Redis最重要的数据结构之一。
我们可以轻松地实现最新消息排行等功能。
Lists的另一个应用就是消息队列,可以利用Lists的PUSH操作,将任务存在Lists中,然后工作线程再用POP操作将任务取出进行执行。

实现方式:
Redis list的实现为一个双向链表,即可以支持反向查找和遍历,更方便操作,不过带来了部分额外的内存开销,Redis内部的很多实现,包括发送缓冲队列等也都是用的这个数据结构。

RPOPLPUSH source destination

命令 RPOPLPUSH 在一个原子时间内,执行以下两个动作:
将列表 source 中的最后一个元素(尾元素)弹出,并返回给客户端。
将 source 弹出的元素插入到列表 destination ,作为 destination 列表的的头元素。
如果 source 和 destination 相同,则列表中的表尾元素被移动到表头,并返回该元素,可以把这种特殊情况视作列表的旋转(rotation)操作。
一个典型的例子就是服务器的监控程序:它们需要在尽可能短的时间内,并行地检查一组网站,确保它们的可访问性。
redis.lpush "downstream_ips", "192.168.0.10"
redis.lpush "downstream_ips", "192.168.0.11"
redis.lpush "downstream_ips", "192.168.0.12"
redis.lpush "downstream_ips", "192.168.0.13"
Then:
next_ip = redis.rpoplpush "downstream_ips", "downstream_ips"

BLPOP

假设现在有 job 、 command 和 request 三个列表,其中 job 不存在, command 和 request 都持有非空列表。考虑以下命令:
BLPOP job command request 30 #阻塞30秒,0的话就是无限期阻塞,job列表为空,被跳过,紧接着command 列表的第一个元素被弹出。
1) "command" # 弹出元素所属的列表
2) "update system..." # 弹出元素所属的值
为什么要阻塞版本的pop呢,主要是为了避免轮询。举个简单的例子如果我们用list来实现一个工作队列。执行任务的thread可以调用阻塞版本的pop去获取任务这样就可以避免轮询去检查是否有任务存在。当任务来时候工作线程可以立即返回,也可以避免轮询带来的延迟。


Set

4、Set

常用命令:
sadd,srem,spop,sdiff ,smembers,sunion 等。

应用场景:
Redis set对外提供的功能与list类似是一个列表的功能,特殊之处在于set是可以自动排重的,当你需要存储一个列表数据,又不希望出现重复数据时,set是一个很好的选择,并且set提供了判断某个成员是否在一个set集合内的重要接口,这个也是list所不能提供的。
比如在微博应用中,每个人的好友存在一个集合(set)中,这样求两个人的共同好友的操作,可能就只需要用求交集命令即可。
Redis还为集合提供了求交集、并集、差集等操作,可以非常方便的实

实现方式:
set 的内部实现是一个 value永远为null的HashMap,实际就是通过计算hash的方式来快速排重的,这也是set能提供判断一个成员是否在集合内的原因。

Sort Set

5、Sorted set

常用命令:
zadd,zrange,zrem,zcard等

使用场景:
以某个条件为权重,比如按顶的次数排序.
ZREVRANGE命令可以用来按照得分来获取前100名的用户,ZRANK可以用来获取用户排名,非常直接而且操作容易。
Redis sorted set的使用场景与set类似,区别是set不是自动有序的,而sorted set可以通过用户额外提供一个优先级(score)的参数来为成员排序,并且是插入有序的,即自动排序。
比如:twitter 的public timeline可以以发表时间作为score来存储,这样获取时就是自动按时间排好序的。
比如:全班同学成绩的SortedSets,value可以是同学的学号,而score就可以是其考试得分,这样数据插入集合的,就已经进行了天然的排序。
另外还可以用Sorted Sets来做带权重的队列,比如普通消息的score为1,重要消息的score为2,然后工作线程可以选择按score的倒序来获取工作任务。让重要的任务优先执行。

需要精准设定过期时间的应用
比如你可以把上面说到的sorted set的score值设置成过期时间的时间戳,那么就可以简单地通过过期时间排序,定时清除过期数据了,不仅是清除Redis中的过期数据,你完全可以把Redis里这个过期时间当成是对数据库中数据的索引,用Redis来找出哪些数据需要过期删除,然后再精准地从数据库中删除相应的记录。


实现方式:
Redis sorted set的内部使用HashMap和跳跃表(SkipList)来保证数据的存储和有序,HashMap里放的是成员到score的映射,而跳跃表里存放的是所有的成员,排序依据是HashMap里存的score,使用跳跃表的结构可以获得比较高的查找效率,并且在实现上比较简单。


消息订阅

6、 Pub/Sub

Pub/Sub 从字面上理解就是发布(Publish)与订阅(Subscribe),在Redis中,你可以设定对某一个key值进行消息发布及消息订阅,
当一个key值上进行了消息发布后,所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统,比如普通的即时聊天,群聊等功能。

客户端1:subscribe rain
客户端2:PUBLISH rain "my love!!!"
(integer) 2 代表有几个客户端订阅了这个消息


Transaction

7、Transactions

谁说NoSQL都不支持事务,虽然Redis的Transactions提供的并不是严格的ACID的事务(比如一串用EXEC提交执行的命令,在执行中服务器宕机,那么会有一部分命令执行了,剩下的没执行),但是这个Transactions还是提供了基本的命令打包执行的功能(在服务器不出问题的情况下,可以保证一连串的命令是顺序在一起执行的,中间有会有其它客户端命令插进来执行)。
Redis还提供了一个Watch功能,你可以对一个key进行Watch,然后再执行Transactions,在这过程中,如果这个Watched的值进行了修改,那么这个Transactions会发现并拒绝执行。
Session 1
(1)第1步
redis 127.0.0.1:6379> get age
"10"
redis 127.0.0.1:6379> watch age
OK
redis 127.0.0.1:6379> multi
OK
redis 127.0.0.1:6379>

Session 2
(2)第2步
redis 127.0.0.1:6379> set age 30
OK
redis 127.0.0.1:6379> get age
"30"
redis 127.0.0.1:6379>

Session 1
(3)第3步
redis 127.0.0.1:6379> set age 20
QUEUED
redis 127.0.0.1:6379> exec
(nil)
redis 127.0.0.1:6379> get age
"30"
redis 127.0.0.1:6379>

第一步,Session 1 还没有来得及对age的值进行修改
  第二步,Session 2 已经将age的值设为30
  第三步,Session 1 希望将age的值设为20,但结果一执行返回是nil,说明执行失败,之后我们再取一下age的值是30,这是由于Session 1中对age加了乐观锁导致的。