亲宝软件园·资讯

展开

Redis 缓存淘汰策略

Miaoshuowen 人气:0

缓存淘汰策略

标题LRU原理

LRU(Least recently used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几率也更高”。

最常见的实现是使用一个链表保存缓存数据,详细算法实现如下:

在Java中可以使用LinkHashMap去实现LRU利用哈希链表实现:

标题Redis缓存淘汰策略

设置最大缓存

在 redis 中,允许用户设置最大使用内存大小maxmemory,默认为0,没有指定最大缓存,如果有新的数据添加,超过最大内存,则会使redis崩溃,所以一定要设置。

redis 内存数据集大小上升到一定大小的时候,就会实行数据淘汰策略。

淘汰策略

redis淘汰策略配置:maxmemory-policy voltile-lru,支持热配置

redis 提供 6种数据淘汰策略:

Redis事务

Redis事务介绍

MULTI

用于标记事务块的开始。 Redis会将后续的命令逐个放入队列中,然后使用EXEC命令原子化地执行这个命令序列。

语法:

multi

EXEC

在一个事务中执行所有先前放入队列的命令,然后恢复正常的连接状态

语法:

exec

DISCARD

清除所有先前在一个事务中放入队列的命令,然后恢复正常的连接状态。

语法:

discard

WATCH

当某个[事务需要按条件执行]时,就要使用这个命令将给定的[键设置为受监控]的状态。

语法:

watch key [key…]

注意事项:使用该命令可以实现 Redis 的乐观锁。

UNWATCH

清除所有先前为一个事务监控的键

语法:

unwatch

命令图解:

事务演示:

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set s1 111
QUEUED
127.0.0.1:6379> hset set1 name zhangsan
QUEUED
127.0.0.1:6379> exec
1) OK
2) (integer) 1
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set s2 222
QUEUED
127.0.0.1:6379> hset set2 age 20
QUEUED
127.0.0.1:6379> discard
OK
127.0.0.1:6379> exec (error) ERR EXEC without MULTI 
127.0.0.1:6379> watch s1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set s1 555
QUEUED 127.0.0.1:6379> exec # 此时在没有exec之前,通过另一个命令窗口对监控的s1字段进行修改 
(nil)
127.0.0.1:6379> get s1
111

Redis 不支持事务回滚(为什么呢)

大多数事务失败是因为语法错误或者类型错误,这两种错误,在开发阶段都是可以预见的Redis 为了性能方面就忽略了事务回滚。

Redis乐观锁

乐观锁基于CAS(Compare And Swap)思想(比较并替换),是不具有互斥性,不会产生锁等待而消耗资源,但是需要反复的重试,但也是因为重试的机制,能比较快的响应。因此我们可以利用redis来

实现乐观锁。具体思路如下:

public void watch() {
	try {
		String watchKeys = "watchKeys";
		//初始值 value=1
		jedis.set(watchKeys, 1);
		//监听key为watchKeys的值
		jedis.watch(watchkeys);
		//开启事务
		Transaction tx = jedis.multi();
		//watchKeys自增加一
		tx.incr(watchKeys);
		//执行事务,如果其他线程对watchKeys中的value进行修改,则该事务将不会执行
		//通过redis事务以及watch命令实现乐观锁
		List<Object> exec = tx.exec();
		if (exec == null) {
			System.out.println("事务未执行");
		} else {
			System.out.println("事务成功执行,watchKeys的value成功修改");
		}
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		jedis.close();
	}
}

Redis乐观锁实现秒杀

public class RedisLock {
    public static void main(String[] arg) {
        //库存key 
        String redisKey = "stock";
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        try {
            Jedis jedis = new RedisProperties.Jedis("127.0.0.1", 6378);
            // 可以被秒杀的库存的初始值,库存总共20个
            jedis.set(redisKey, "0");
            jedis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1000; i++) {
            executorService.execute(() -> {
                Jedis jedis1 = new Jedis("127.0.0.1", 6378);
                try {
                    jedis1.watch(redisKey);
                    String redisValue = jedis1.get(redisKey);
                    int valInteger = Integer.valueOf(redisValue);
                    String userInfo = UUID.randomUUID().toString();
                    // 没有秒完
                    if (valInteger < 20) {
                        Transaction tx = jedis1.multi();
                        tx.incr(redisKey);
                        List list = tx.exec();
                        // 秒成功 失败返回空list而不是空
                        if (list != null && list.size() > 0) {
                            System.out.println("用户:" + userInfo + ",秒杀成 功!当前成功人数:" + (valInteger + 1));
                        }
                        // 版本变化,被别人抢了。
                        else {
                            System.out.println("用户:" + userInfo + ",秒杀失 败");
                        }
                    }
                    // 秒完了
                    else {
                        System.out.println("已经有20人秒杀成功,秒杀结束");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    jedis1.close();
                }
            });
        }
        executorService.shutdown();
    }
}

加载全部内容

相关教程
猜你喜欢
用户评论