分类 redis 下的文章

2024-09-04

为了保证缓存和数据库的一致性，可以采用以下策略：

写入数据库后删除缓存：
先写数据库，成功后删除缓存。这种方式简单，但可能存在数据不一致的情况，因为删除缓存可能失败。
写入数据库前删除缓存：
先删除缓存，再写数据库。这种方式能保证一致性，但可能存在并发问题。
使用事务：
将数据库操作和缓存操作放在同一个事务中。这种方式能保证原子性，一旦事务提交，数据库和缓存状态就会保持一致。

示例代码（使用Python和Redis）：




import redis
import sqlalchemy
from sqlalchemy.orm import sessionmaker
 
# 初始化数据库会话
engine = sqlalchemy.create_engine('sqlite:///mydatabase.db')
Session = sessionmaker(bind=engine)
session = Session()
 
# 初始化Redis连接
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 删除缓存
def delete_cache(key):
    r.delete(key)
 
# 写入数据库并删除相应的缓存
def write_to_db_and_delete_cache(key, value):
    # 假设有一个模型Model和对应的表
    class Model(Base):
        __tablename__ = 'my_table'
        id = Column(Integer, primary_key=True)
        data = Column(String)
    
    # 写入数据库
    new_item = Model(data=value)
    session.add(new_item)
    session.commit()
    
    # 删除缓存
    delete_cache(key)
 
# 使用示例
key = 'my_key'
value = 'my_value'
write_to_db_and_delete_cache(key, value)

在实际应用中，可能需要结合具体的业务场景来选择最合适的策略。例如，可以使用锁或者队列来处理并发问题，或者采用更复杂的策略如延迟双删策略（延迟删除缓存直到数据更新操作完成）等。

- 阅读更多 -

Redis常见的数据类型和应用场景

System

2024-09-04

所有,redis

Redis 提供了五种不同类型的数据结构，每种数据结构有着特定的应用场景：

String：字符串是最基本的 key-value 结构。常用于存储用户信息、会话信息、配置参数等。
应用场景：
```
# 设置用户信息
redis.set('user:100:name', 'Alice')
# 获取用户信息
name = redis.get('user:100:name')
```

Hash：Hash 是键值对的集合。常用于存储用户信息、配置参数等。

应用场景：




# 设置用户信息
redis.hset('user:100', 'name', 'Alice')
redis.hset('user:100', 'age', '25')
# 获取用户信息
user_info = redis.hgetall('user:100')

List：列表是顺序的字符串列表，可以添加删除元素。常用于消息队列、文章列表等。

应用场景：




# 添加文章到列表
redis.lpush('user:100:posts', 'post1', 'post2', 'post3')
# 获取文章列表
posts = redis.lrange('user:100:posts', 0, -1)

Set：集合是无序的字符串集合，可以添加删除元素。常用于去重、共同好友、共同兴趣等。

应用场景：




# 添加好友
redis.sadd('user:100:friends', 'friend1', 'friend2', 'friend3')
# 获取所有好友
friends = redis.smembers('user:100:friends')

Sorted Set：有序集合是有分数的集合，可以根据分数排序。常用于排行榜、延时任务调度等。

应用场景：




# 添加用户分数
redis.zadd('leaderboard', {'user1': 100, 'user2': 200})
# 获取排行榜前10名
leaderboard = redis.zrange('leaderboard', 0, 9)

以上是 Redis 数据类型的简单介绍和使用示例，实际应用中可能还会涉及更复杂的使用方法，如事务处理、发布订阅等。

System

2024-09-04

所有,redis

在计算机科学中，LRU是一种缓存置换算法，目的是减少数据访问的时间开销。LRU算法的核心是“如果数据最近被访问过，那么在将来被访问的可能性也较高”。

Redis作为一种内存数据库，其中的数据都保存在内存中，为了保证Redis的性能，Redis会根据数据的访问情况来决定是否保留数据。在Redis中，LRU算法被用于决定何时淘汰不常使用的键。

Redis的LRU算法实现主要在redis.c文件中的freeMemoryIfNeeded函数中，该函数会在执行命令之前被调用，以确保Redis的内存使用量不超过配置的最大内存量。

以下是Redis中实现LRU算法的核心函数部分：




/* 在需要的情况下释放内存 */
void freeMemoryIfNeeded(void) {
    /* 如果超出最大内存限制，则开始清除键 */
    while (server.maxmemory && zmalloc_used_memory() > server.maxmemory) {
        int samples = 5;
        int j, k;
        /* 在一定的样本数内，选择一个最近未被访问的键 */
        for (j = 0; j < samples; j++) {
            k = rand() % dbTotalSize;
            dictEntry *de = dictGetRandomKey(dbDict + k);
            redisDb *db = dbDict[k];
            robj *key = dictGetKey(de);
            robj *val = dictGetVal(de);
            time_t when = val->lru;
 
            /* 更新LRU时间 */
            val->lru = server.lruclock;
            /* 将键值对保存到一个临时的数据库中 */
            db->expires[k] = db->expires_cursor;
            db->expires_cursor = de;
            /* 将键值对从当前数据库移动到临时数据库 */
            dictAdd(db->dict, key, val);
            dictAdd(db->expires, key, val);
            dictUnlink(db->dict, key);
            dictUnlink(db->expires, key);
 
            /* 如果找到了一个最近未被访问的键，则释放其空间，并停止搜索 */
            if (server.maxmemory_policy & MAXMEMORY_FLAG_LRU) {
                freeObjFromDb(db, key, val);
            }
        }
    }
}

在这个函数中，Redis会随机选取一些键，检查它们的最后一次被访问的时间，并根据这个时间来决定是否释放它们的空间。如果选取的键已经很长时间没有被访问，它们将被释放，从而保证了Redis的内存使用量不会超过配置的最大内存量。

这只是Redis中实现LRU算法的一个简化示例，实际的Redis实现要复杂得多，包括了多线程和更复杂的内存管理策略。

- 阅读更多 -

Docker安装配置Redis

System

2024-09-04

所有,redis

以下是一个简单的示例，展示如何使用Docker安装和配置Redis服务：

创建一个名为 docker-compose.yml 的文件，内容如下：




version: '3'
services:
  redis:
    image: redis:latest
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    networks:
      - net
 
networks:
  net:
 
volumes:
  redis-data:
    driver: local

在包含该 docker-compose.yml 文件的目录中，运行以下命令来启动Redis服务：




docker-compose up -d

确认Redis服务运行：




docker ps

这将下载最新的Redis Docker镜像，将6379端口从Docker容器映射到主机，并启动Redis服务器。它还将数据卷用于持久化存储，并启用了追加模式。

- 阅读更多 -

springboot 缓存框架Cache整合redis组成二级缓存

System

2024-09-04

所有,redis

要在Spring Boot项目中使用Redis作为二级缓存，你可以使用Spring Cache抽象层以及spring-boot-starter-data-redis依赖。以下是整合Redis作为二级缓存的步骤和示例代码：

添加依赖到pom.xml：




<dependencies>
    <!-- Spring Boot Data Redis Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- Spring Boot Cache Abstraction -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
</dependencies>

在application.properties或application.yml中配置Redis连接：




# application.properties
spring.redis.host=localhost
spring.redis.port=6379

在Spring Boot应用中启用缓存：




import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@EnableCaching
public class CacheConfig {
}

使用缓存注解：




import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
 
@Service
public class SomeService {
 
    @Cacheable(value = "secondaryCache", key = "#key", condition = "#key.length() < 10")
    public String someMethod(String key) {
        // 实现逻辑
        return "result";
    }
}

在上述代码中，@Cacheable注解被用来指定someMethod的返回结果应该被缓存。缓存的名字是secondaryCache，并且使用key作为缓存的键。condition属性用于指定只有当key的长度小于10时才会缓存结果。

确保你的Redis服务器正在运行并且配置正确，这样Spring Boot应用就会自动将数据缓存到Redis中，作为二级缓存来使用。

- 阅读更多 -

nosql----redis三主三从集群部署

System

2024-09-04

所有,redis

为了部署一个Redis三主三从集群，你需要准备六个Redis节点，三个主节点和三个从节点。以下是部署Redis集群的基本步骤：

安装Redis并确保每个节点上的Redis版本一致。
配置每个Redis实例的redis.conf文件，设置不同的端口和持久化文件路径。
使用Redis的--slaveof参数配置主从关系。

以下是示例配置：

redis-6379.conf (主节点)




port 6379
dir /var/lib/redis

redis-6380.conf (主节点)




port 6380
dir /var/lib/redis

redis-6381.conf (主节点)




port 6381
dir /var/lib/redis

redis-6382.conf (从节点)




port 6382
dir /var/lib/redis
slaveof 127.0.0.1 6379

redis-6383.conf (从节点)




port 6383
dir /var/lib/redis
slaveof 127.0.0.1 6380

redis-6384.conf (从节点)




port 6384
dir /var/lib/redis
slaveof 127.0.0.1 6381

启动每个Redis实例：




redis-server /path/to/redis-6379.conf
redis-server /path/to/redis-6380.conf
redis-server /path/to/redis-6381.conf
redis-server /path/to/redis-6382.conf
redis-server /path/to/redis-6383.conf
redis-server /path/to/redis-6384.conf

确保防火墙和安全组设置允许相应端口的流量。

这样就部署了一个基本的Redis三主三从集群。为了更高的可用性和数据一致性，你可能还需要考虑使用Redis Sentinel或者Redis Cluster。

- 阅读更多 -

SpringBoot整合Redis：Redis优化解决数据一致性问题

System

2024-09-04

所有,redis




import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import java.util.Collections;
 
@Service
public class RedisService {
 
    private final StringRedisTemplate stringRedisTemplate;
    private final DefaultRedisScript<Long> lockScript;
    private final DefaultRedisScript<Long> unlockScript;
 
    public RedisService(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
 
        // 定义Lua脚本用于加锁
        String lockScriptSource = "if redis.call('exists', KEYS[1]) == 0 then redis.call('hset', KEYS[1], ARGV[1], 1); redis.call('pexpire', KEYS[1], ARGV[2]); return 1; else return 0; end";
        lockScript = new DefaultRedisScript<>();
        lockScript.setScriptText(lockScriptSource);
        lockScript.setResultType(Long.class);
 
        // 定义Lua脚本用于解锁
        String unlockScriptSource = "if redis.call('hexists', KEYS[1], ARGV[1]) == 1 then redis.call('hdel', KEYS[1], ARGV[1]); return 1; else return 0; end";
        unlockScript = new DefaultRedisScript<>();
        unlockScript.setScriptText(unlockScriptSource);
        unlockScript.setResultType(Long.class);
    }
 
    public boolean lock(String lockKey, String requestId, int expireTime) {
        Long result = stringRedisTemplate.execute(lockScript, Collections.singletonList(lockKey),
                Collections.singletonList(requestId), Collections.singletonList(String.valueOf(expireTime)));
        return result != null && result.intValue() == 1;
    }
 
    public boolean unlock(String lockKey, String requestId) {
        Long result = stringRedisTemplate.execute(unlockScript, Collections.singletonList(lockKey),
                Collections.singletonList(requestId));
        return result != null && result.intValue() == 1;
    }
}

这段代码示例展示了如何使用Spring Data Redis的StringRedisTemplate和DefaultRedisScript来实现分布式锁。通过Lua脚本来保证在解锁时的原子性，避免了由于网络分区或其他问题导致的解锁失败问题。这是一个简化的示例，但在实际应用中，你可能需要添加更多的错误处理和重试逻辑。

- 阅读更多 -

基本知识和如何安装python，mongodb，redis

System

2024-09-04

所有,redis

安装Python、MongoDB和Redis的基本步骤如下：

Python安装：
- Windows: 访问Python官方网站下载安装包，运行安装程序。
- macOS: 使用Homebrew，在终端运行 brew install python3。
- Linux: 使用包管理器，如Ubuntu中使用 sudo apt-get install python3。
MongoDB安装：
- Windows: 访问MongoDB官方网站下载安装包，运行安装程序。
- macOS: 使用Homebrew，在终端运行 brew install mongodb。
- Linux: 使用包管理器，如Ubuntu中使用 sudo apt-get install mongodb。
Redis安装：
- Windows: 下载Redis官方提供的Windows版本，解压后运行 redis-server.exe。
- macOS: 使用Homebrew，在终端运行 brew install redis。
- Linux: 使用包管理器，如Ubuntu中使用 sudo apt-get install redis-server。

以下是在Linux系统中使用apt-get安装MongoDB和Redis的示例代码：




# 更新包管理器的包列表
sudo apt-get update
 
# 安装MongoDB
sudo apt-get install -y mongodb
 
# 启动MongoDB服务
sudo systemctl start mongodb
 
# 使MongoDB服务开机自启
sudo systemctl enable mongodb
 
# 安装Redis
sudo apt-get install -y redis-server
 
# 启动Redis服务
sudo systemctl start redis-server
 
# 使Redis服务开机自启
sudo systemctl enable redis-server

请根据您的操作系统和需求选择合适的安装方式。对于生产环境，您可能需要考虑更复杂的配置和安全设置。

- 阅读更多 -

mysql和Redis如何保持数据一致性

System

2024-09-04

所有,redis

在保持MySQL和Redis数据一致性的场景中，可以使用以下方法：

更新MySQL后更新Redis：
在更新数据库之后，同步更新Redis。如果更新Redis失败，可以考虑使用事务回滚。
使用MySQL的binlog：
配置MySQL开启binlog，监听binlog的变更来同步更新Redis。
使用数据库事务：
保证MySQL操作和Redis操作在同一个数据库事务内部执行。

以下是使用MySQL事务同步数据到Redis的伪代码示例：




-- 开启MySQL事务
START TRANSACTION;
 
-- 更新MySQL数据
UPDATE your_table SET column = value WHERE condition;
 
-- 更新Redis数据
HSET your_redis_key field value;
 
-- 如果Redis更新失败，回滚MySQL事务
-- 注意：这里的Redis更新失败需要捕获异常或者通过某种方式检测到
ROLLBACK;
 
-- 提交事务
COMMIT;

确保在更新Redis时使用的是原子操作，以保证数据一致性。如果Redis服务器不可用，考虑使用重试逻辑或者将需要同步的数据存储在本地队列中，然后在Redis恢复服务后再进行同步。

- 阅读更多 -

【Linux】Redis的启动、使用和停止

System

2024-09-04

所有,redis

Redis是一个开源的使用C语言编写的、支持网络通信的、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

在Linux环境下，我们可以通过以下方式来启动、使用和停止Redis服务：

启动Redis

Redis的启动方式有很多种，下面列出了几种常见的方式：

直接启动

你可以直接在Redis的源码目录下使用make install命令安装Redis，安装完成后，你可以在安装目录下使用redis-server命令来启动Redis服务器。




$ redis-server

使用配置文件启动

你也可以通过指定配置文件的方式来启动Redis，例如你有一个配置文件叫做redis.conf，你可以使用以下命令来启动Redis：




$ redis-server /path/to/your/redis.conf

使用Redis初始化脚本启动

如果你是通过包管理器（如apt-get或yum）安装的Redis，那么你可以使用初始化脚本来启动Redis。例如，在基于systemd的系统上，你可以使用以下命令来启动Redis：




$ sudo systemctl start redis

使用Redis

启动Redis服务器后，你可以使用redis-cli命令来连接到Redis服务器，并执行Redis命令。例如：




$ redis-cli
127.0.0.1:6379> SET key "Hello, World!"
OK
127.0.0.1:6379> GET key
"Hello, World!"

停止Redis

你可以通过以下方式来停止Redis服务：

直接停止

如果你是通过前面提到的方式直接启动Redis的，那么你可以直接使用Ctrl + C来停止Redis服务器。

使用Redis客户端

你也可以通过Redis客户端发送SHUTDOWN命令来停止Redis服务器：




$ redis-cli SHUTDOWN

使用Redis初始化脚本停止

如果你是通过systemd初始化脚本启动Redis的，那么你可以使用以下命令来停止Redis：




$ sudo systemctl stop redis

注意：以上的命令和方法可能会根据你的Linux发行版和Redis的安装方式有所不同。

- 阅读更多 -