基于redis的缓存机制的思考和优化-低调大师

基于redis的缓存机制的思考和优化

2018-02-24 696

基于redis的缓存机制的思考和优化

相对我们对于redis的使用场景都已经想当的熟悉。对于大量的数据，为了缓解接口（数据库）的压力，我们对查询的结果做了缓存的策略。一开始我们的思路是这样的。

1.执行查询

2.缓存中存在数据 -> 查询缓存

3.缓存中不存在数据 -> 查询实时接口

对此，我简单模拟了我们的缓存机制。

这是一个查询实时的服务

[java] view plain copy

package yyf.Jedis.toolsByRedis.cacheCacheTools;
/**
* 模拟服务
* @author yuyufeng
*
*/
public class BaseService {
public String query(String req) {
return "hello:" + req;
}
}

从代码中我们可以看到，这个服务反应应该是非常快的。

[java] view plain copy

package yyf.Jedis.toolsByRedis.cacheCacheTools;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class CacheCacheToolTest {
static JedisPool jedisPool;
static {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(100);
config.setMaxIdle(5);
config.setMaxWaitMillis(1000);
config.setTestOnBorrow(false);
jedisPool = new JedisPool(config, "127.0.0.1", 6379, 1000);
Jedis jedis = jedisPool.getResource();
jedisPool.returnResource(jedis);
}
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
new Thread(){@Override
public void run() {
//执行查询
query();
}}.start();
}
}
public static void query() {
BaseService bs = new BaseService();
Jedis jedis = jedisPool.getResource();
String req = "test123";
String res;
if (jedis.get(req) == null) {
System.out.println("##查询接口服务");
res = bs.query(req);
jedis.setex(req, 10, res);
} else {
System.out.println("##查询缓存");
res = jedis.get(req);
}
System.out.println(res);
jedisPool.returnResource(jedis);
}
}

当5个并发进来的时候，第一个查询实时服务，其余的查询缓存。

[java] view plain copy

##查询接口服务
hello:test123
##查询缓存
##查询缓存
##查询缓存
hello:test123
hello:test123
hello:test123
##查询缓存
hello:test123

看到结果，我们似乎觉得这个查询非常的合理，当时当我们的实时接口查询速度很慢的时候，就暴露出问题来了。

[java] view plain copy

package yyf.Jedis.toolsByRedis.cacheCacheTools;
/**
* 模拟服务
* @author yuyufeng
*
*/
public class BaseService {
public String query(String req) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "hello:" + req;
}
}

[java] view plain copy

##查询接口服务
##查询接口服务
##查询接口服务
##查询接口服务
##查询接口服务
hello:test123
hello:test123
hello:test123
hello:test123
hello:test123

结果是，全部都查询的接口服务。这样会导致并发一高，缓存就相当于作用非常小了。

如果在查询实时过程时，对于相同的请求，能够让其等待，那么效率会有大大的提升：（为了模拟，加锁处理）

[java] view plain copy

public static void main(String[] args) {
beginTime = System.currentTimeMillis();
for (int i = 0; i < 5; i++) {
new Thread(){@Override
public void run() {
//执行查询
synchronized (args) {
query();
}
//System.out.println(System.currentTimeMillis()-beginTime);
}}.start();
}
}

[java] view plain copy

##查询缓存
hello:test123
##查询缓存
hello:test123
##查询缓存
hello:test123
##查询缓存
hello:test123
##查询缓存
hello:test123

现在就都是查询缓存了。其实对于查询并发这样做是比好的。打个比方：

一堆人需要从一个出口出去，这个出口有一个小门已经可以通过，还有一个大门未打开，需要从小门出去打开。这个大门非常大（redis查询速度非常快）。如果大批的人同时出去（高并发），那么必然在小门挤很长的时间。此时，如果现有一个人去把大门先打开，那么后面的人（包括本来要挤小门的人）可以直接从大门出去，效率肯定是后面的划算。

对于查询实时一次比较慢的情况下，可以先让一个线程进去。让其它线程等待。

当然，这样并不完美。当缓存失效，那么查询就会卡顿一下。为了保证用户能一直流畅的查询，我有如下两种方案：

1.在缓存存在的时间里的进行异步查询去更新缓存。

2.使用二级缓存，并且当一级缓存失效的时候，会去读取二级缓存，二级缓存异步更新。（二级缓存的时间可以很长）

下面是第一种策略的代码模拟：

[java] view plain copy

public static void query() {
BaseService bs = new BaseService();
Jedis jedis = jedisPool.getResource();
String req = "test123";
String res;
if (jedis.get(req) == null) {
System.out.println("##查询接口服务");
res = bs.query(req);
jedis.setex(req, 100, res);
} else {
System.out.println("##查询缓存");
res = jedis.get(req);
System.out.println("缓存剩余时间："+jedis.ttl(req));
// 当时间超过10秒，异步更新数据到缓存
if (jedis.ttl(req) < 90) {
//模拟得到推送，接受推送，执行
new Thread() {
@Override
public void run() {
String res = bs.query(req);
jedis.setex(req, 100, res);
System.out.println("异步更新数据："+req);
}
}.start();
}
}
System.out.println(res);
jedisPool.returnResource(jedis);
}

运行结果：

[java] view plain copy

##查询缓存
缓存剩余时间：67
hello:test123
##查询缓存
缓存剩余时间：67
hello:test123
##查询缓存
缓存剩余时间：67
hello:test123
##查询缓存
缓存剩余时间：67
hello:test123
##查询缓存
缓存剩余时间：67
hello:test123
异步更新数据：test123
异步更新数据：test123
异步更新数据：test123
异步更新数据：test123
异步更新数据：test123

为了保证一段时间内，更新一个缓存只执行一次，做如下锁

[java] view plain copy

public static void main(String[] args) {
beginTime = System.currentTimeMillis();
for (int i = 0; i < 5; i++) {
new Thread() {
@Override
public void run() {
// 执行查询
query();
// System.out.println(System.currentTimeMillis()-beginTime);
}
}.start();
}
}
public static void query() {
BaseService bs = new BaseService();
Jedis jedis = jedisPool.getResource();
String req = "test123";
String res;
System.out.println(jedis.get(req));
if (jedis.get(req) == null) {
System.out.println("##查询接口服务");
res = bs.query(req);
jedis.setex(req, 100, res);
} else {
System.out.println("##查询缓存");
res = jedis.get(req);
System.out.println("缓存剩余时间："+jedis.ttl(req));
// 当时间超过10秒，异步更新数据到缓存
if (jedis.ttl(req) < 90) {
//模拟得到推送，接受推送，执行
new Thread() {
@Override
public void run() {
//保证5秒内，一条数据只更新一次
Long incr = jedis.incr("incr-flag-"+req);
jedis.expire("incr-flag-"+req, 5);
if(1 == incr){
String resT = bs.query(req);
jedis.setex(req, 100, resT);
System.out.println("异步更新数据："+req);
}
}
}.start();
}
}
jedisPool.returnResource(jedis);
}

运行两次，间隔10秒。运行结果：

[java] view plain copy

hello:test123
##查询缓存
hello:test123
hello:test123
hello:test123
hello:test123
##查询缓存
##查询缓存
##查询缓存
##查询缓存
异步更新数据：test123

这样，即可保证一次查询比较耗时的情况下，用户能流畅的查询。用户体验大大提升

原文地址http://www.bieryun.com/1718.html

微信关注我们

原文链接：https://yq.aliyun.com/articles/494345

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Java并发编程 -- synchronized保证线程安全的原理

文章转载致博客 http://blog.csdn.net/javazejian/article/details/72828483 自己稍加完善。线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点，一是存在共享数据(也称临界资源)，二是存在多条线程共同操作共享数据。因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁后，在同一个时刻，其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁。在 Java 中，关键字 synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时我们还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代Volati...

2018-02-25

575

Spring整合Shiro使用EL表达式

Shiro是一个轻量级的权限控制框架，应用非常广泛。本文的重点是介绍Spring整合Shiro，并通过扩展使用Spring的EL表达式，使@RequiresRoles等支持动态的参数。对Shiro的介绍则不在本文的讨论范围之内，读者如果有对shiro不是很了解的，可以通过其官方网站了解相应的信息。infoq上也有一篇文章对shiro介绍比较全面的，也是官方推荐的，其地址是https://www.infoq.com/articles/apache-shiro。 Shiro整合Spring 首先需要在你的工程中加入shiro-spring-xxx.jar，如果是使用Maven管理你的工程，则可以在你的依赖中加入以下依赖，笔者这里是选择的当前最新的1.4.0版本。 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.4.0</version> </depende...

2018-02-25

560

发表评论

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。