标签 redis 下的文章

2024-09-04

Redis提供了几种删除数据的策略，以下是三种删除数据的策略以及对应的逐出算法：

定时淘汰：每个key都有自己的过期时间，当过期时间到达时，会被自动删除。
惰性删除：只有当访问key时，才会检查是否过期，如果过期就删除。
定期淘汰：每隔一段时间，会随机抽查一些key，检查是否过期，并删除。

以下是对应的逐出算法：

随机逐出(Random Eviction)：随机选择一些key进行检查。
总数逐出(Volatile Random)：从设置了过期时间的key中随机选择一些进行检查。
已使用的内存逐出(Volatile TTL)：从设置了过期时间的key中选择近期将要过期的key进行检查。
内存使用率逐出(Volatile LRU)：根据LRU算法选择一些key进行检查。
最近使用的逐出(LRU)：根据LRU算法选择一些key进行检查。

注意：Redis并没有直接使用LRU算法，而是使用了类似的随机逐出(Random Eviction)和已使用的内存逐出(Volatile LRU)策略。

示例代码：




import redis
 
# 连接Redis
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 设置key，并设置过期时间
r.set('key', 'value', ex=10)  # ex表示过期时间，单位为秒
 
# 定时淘汰：Redis会自动删除过期的key
# 定期淘汰：Redis会定期检查一些key是否过期并删除
# 惰性删除：当访问key时，Redis会检查是否过期，如果过期就删除
 
# 查看key是否存在
exists = r.exists('key')
print(f"Key exists: {exists}")
 
# 删除key
r.delete('key')
 
# 检查key是否存在
exists = r.exists('key')
print(f"Key exists: {exists}")

在这个例子中，我们首先连接到Redis，然后设置了一个key并设置了过期时间。Redis将自动处理过期的key，通过定时淘汰、定期淘汰和惰性删除策略。最后，我们检查key是否存在，并删除它。

Redis+Caffeine 实现两级缓存实战

2024-09-04




import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import redis.clients.jedis.Jedis;
 
public class RedisCaffeineCache {
    private final Jedis jedis;
    private final Cache<String, String> caffeineCache;
 
    public RedisCaffeineCache(Jedis jedis) {
        this.jedis = jedis;
        this.caffeineCache = Caffeine.newBuilder()
                .maximumSize(10_000)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build();
    }
 
    public String get(String key) {
        // 先从Caffeine缓存获取
        String value = caffeineCache.getIfPresent(key);
        if (value == null) {
            // Caffeine缓存未命中，从Redis获取
            value = jedis.get(key);
            if (value != null) {
                // 将获取的数据存入Caffeine缓存
                caffeineCache.put(key, value);
            }
        }
        return value;
    }
 
    public void put(String key, String value) {
        // 直接写入Redis
        jedis.set(key, value);
        // 同时写入Caffeine缓存
        caffeineCache.put(key, value);
    }
 
    public void evict(String key) {
        // 从Redis删除
        jedis.del(key);
        // 从Caffeine缓存删除
        caffeineCache.invalidate(key);
    }
}

这个示例代码展示了如何使用Redis和Caffeine实现两级缓存。get方法首先检查Caffeine缓存，如果未命中，再去Redis查询。put方法直接将数据存入Redis，并同时更新Caffeine缓存。evict方法会从Redis和Caffeine缓存中删除一个键值对。

【入门篇】1.4 redis 客户端之 Lettuce 详解

2024-09-04

Lettuce 是一个高级 Redis 客户端，用于线程安全的、可编程的、异步和同步的 Redis 连接。它提供了一个清晰的API，并且可以用于构建非块的、高性能的应用程序。

Lettuce 的主要特性包括：

同步和异步的连接以及编程模型。
高级的 Redis 集群支持，包括自动发现和完整的集群通信。
高度可定制的超时和重试机制。
可以使用 Netty 线程池或者 Reactor 线程模型。
完整的 Redis 命令支持和实现。
可以使用 Redis 的新特性，比如 ACLLOGSTORE。

以下是一个使用 Lettuce 连接 Redis 并执行基本命令的示例代码：




import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;
 
public class LettuceExample {
    public static void main(String[] args) {
        // 连接到 Redis 服务器
        RedisClient redisClient = RedisClient.create("redis://localhost");
        StatefulRedisConnection<String, String> connection = redisClient.connect();
        RedisCommands<String, String> syncCommands = connection.sync();
 
        // 设置键值对
        syncCommands.set("key", "value");
 
        // 获取键对应的值
        String value = syncCommands.get("key");
        System.out.println("key 对应的值是: " + value);
 
        // 关闭连接
        connection.close();
        redisClient.shutdown();
    }
}

在这个例子中，我们创建了一个 RedisClient 实例，然后使用它连接到本地的 Redis 服务器。接着，我们通过连接获取了同步命令接口 RedisCommands，并使用它来执行 set 和 get 命令。最后，我们关闭了连接和客户端，释放资源。

Linux常用软件安装（JDK、MySQL、Tomcat、Redis）

2024-09-04

所有,java

以下是在Linux环境下安装JDK、MySQL、Tomcat和Redis的简要步骤和示例代码：

JDK安装

下载JDK：




wget --no-check-certificate -c --header "Cookie: oraclelicense=accept-securebackup-cookie" \
http://download.oracle.com/otn-pub/java/jdk/8u151-b12/jdk-8u151-linux-x64.tar.gz

解压JDK：




tar -xzf jdk-8u151-linux-x64.tar.gz

设置环境变量：




export JAVA_HOME=/path/to/jdk1.8.0_151
export PATH=$PATH:$JAVA_HOME/bin

MySQL安装

对于Ubuntu/Debian系统：




sudo apt-get update
sudo apt-get install mysql-server

对于CentOS/RHEL系统：




sudo yum update
sudo yum install mysql-server

Tomcat安装

下载Tomcat：




wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.37/bin/apache-tomcat-9.0.37.tar.gz

解压Tomcat：




tar -xzf apache-tomcat-9.0.37.tar.gz

启动Tomcat：




cd apache-tomcat-9.0.37/bin
./startup.sh

Redis安装

对于Ubuntu/Debian系统：




sudo apt-get update
sudo apt-get install redis-server

对于CentOS/RHEL系统：




sudo yum update
sudo yum install redis

这些命令假设您有sudo权限，并且您正在使用的Linux发行版是最常见的几种之一。对于其他发行版或特定版本的JDK、MySQL、Tomcat或Redis，您可能需要修改安装命令以适应特定的包管理器或下载页面。

Redis【实战篇】---- 分布式锁-redission

2024-09-04

在Redis中实现分布式锁通常使用SETNX命令（或在Redis 2.6.12以上版本中使用SET key value EX max-lock-time NX命令，这样可以一次性设置并加锁，避免了两条命令之间客户端被阻塞的问题）。以下是一个使用SET命令实现分布式锁的Python示例：




import redis
import time
import uuid
 
def acquire_lock(conn, lock_name, acquire_timeout=10, lock_timeout=10):
    identifier = str(uuid.uuid4())  # 生成一个唯一的ID
    end = time.time() + acquire_timeout
 
    while time.time() < end:
        if conn.set(lock_name, identifier, ex=lock_timeout, nx=True):
            return identifier  # 加锁成功，返回唯一标识
        time.sleep(0.001)
 
    return False  # 在规定时间内未能获得锁
 
def release_lock(conn, lock_name, identifier):
    pipe = conn.pipeline(True)
    while True:
        try:
            pipe.watch(lock_name)
            if pipe.get(lock_name) == identifier:
                pipe.multi()
                pipe.delete(lock_name)
                pipe.execute()
                return True
            pipe.unwatch()
            break
        except redis.exceptions.WatchError:
            pass
    return False  # 释放锁失败，可能由于标识符不匹配
 
# 使用示例
client = redis.StrictRedis(host='localhost', port=6379, db=0)
lock_name = "my_lock"
lock_identifier = acquire_lock(client, lock_name)
if lock_identifier:
    try:
        # 在这个区块内执行需要互斥的操作
        print("Lock acquired")
    finally:
        if not release_lock(client, lock_name, lock_identifier):
            print("Failed to release lock")
else:
    print("Failed to acquire lock")

这段代码中，acquire_lock函数尝试获取一个分布式锁，如果在指定时间内成功，它会返回一个唯一标识符；release_lock函数尝试释放由该唯一标识符持有的锁。如果标识符匹配并成功释放锁，函数返回True；如果标识符不匹配或者释放锁时发生错误，函数返回False。在实际应用中，你需要确保在获取锁之后及异常发生时释放锁，以避免死锁情况的发生。

2024-09-04




#!/bin/bash
# 快速编译安装 PHP 8.3.3 并配置常用扩展：redis、zip、igbinary、memcached
 
# 定义 PHP 版本和源代码目录变量
PHP_VERSION="php-8.3.3"
SRC_DIR="/usr/local/src"
 
# 安装依赖库
yum install -y epel-release \
    && yum install -y \
    gcc \
    gcc-c++ \
    make \
    zlib-devel \
    openssl-devel \
    libxml2-devel \
    bzip2-devel \
    curl-devel \
    freetype-devel \
    gmp-devel \
    libmcrypt-devel \
    libpng-devel \
    libjpeg-turbo-devel \
    libzip-devel \
    recode-devel \
    libicu-devel \
    libxslt-devel \
    systemd-devel \
    pcre-devel \
    sqlite-devel \
    oniguruma-devel \
    libwebp-devel \
    libc-client-devel \
    openldap-devel
 
# 下载 PHP 源代码
cd $SRC_DIR \
    && wget "https://www.php.net/distributions/$PHP_VERSION.tar.gz" \
    && tar -zxvf "$PHP_VERSION.tar.gz" \
    && cd "$PHP_VERSION"
 
# 配置编译选项
./configure \
    --prefix=/usr/local/php8 \
    --with-curl \
    --with-freetype \
    --with-gd \
    --with-gettext \
    --with-iconv-dir \
    --with-kerberos \
    --with-libdir=lib64 \
    --with-libxml-dir \
    --with-mysqli \
    --with-openssl \
    --with-pcre-regex \
    --with-pear \
    --with-pdo-mysql \
    --with-pdo-sqlite \
    --with-pear \
    --with-png-dir \
    --with-xmlrpc \
    --with-xsl \
    --with-zlib \
    --enable-bcmath \
    --enable-fpm \
    --enable-gd-jis-conv \
    --enable-inline-optimization \
    --enable-mbregex \
    --enable-mbstring \
    --enable-opcache \
    --enable-pcntl \
    --enable-shmop \
    --enable-soap \
    --enable-sockets \
    --enable-sysvsem \
    --enable-xml \
    --enable-zip \
    --disable-debug \
    --disable-rpath \
    --disable-fileinfo
 
# 编译并安装 PHP
make -j$(nproc) && make install
 
# 配置 PHP
cp php.ini-development /usr/local/php8/lib/php.ini
cp /usr/local/php8/etc/php-fpm.conf.default /usr/local/php8/etc/php-fpm.conf
cp /usr/local/php8/etc/php-fpm.d/www.conf.default /usr/local/php8/etc/php-fpm.d/www.conf
 
# 下载并编译安装 PHP 扩展
for extension in redis zip igbinary memcached; do
    cd $SRC_DIR \
    && git clone "https://github.com/php/$extension-ds.git" \
    && cd "$extension-ds" \
    && phpize \
    && ./configure --with-php-config=/usr/local/php8/bin/php-config \
    && make && make install
done
 
# 配置 PHP 加载扩展
extension_dir="/usr/local/php8/lib/php/extensions/no-debug-non-zts-20210902"
for extension in redis zip igbinary memcached; do
    echo "extension=$

Redis中的持久化详解

2024-09-04

Redis的持久化主要有两种方式：RDB（Redis DataBase）和AOF（Append Only File）。

RDB：定时将内存中的数据快照保存到磁盘的一个压缩二进制文件中。可以配置定时任务来控制快照的频率。




# 配置保存点（在redis.conf中设置）
save 900 1      # 900秒内至少1个键被修改则保存
save 300 10     # 300秒内至少10个键被修改则保存
save 60 10000   # 60秒内至少10000个键被修改则保存

AOF：每个写命令都通过append操作保存到文件中。在服务重启时，通过重放这些命令来恢复数据。




# 配置AOF持久化（在redis.conf中设置）
appendonly yes       # 开启AOF持久化
appendfilename "appendonly.aof"  # AOF文件名
# appendfsync always   # 每个命令都同步，最慢但最安全
# appendfsync everysec # 每秒同步一次，折衷方案
# appendfsync no       # 由操作系统决定何时同步

在实际应用中，可以两者结合使用，或者只使用其中一种。根据需求和性能考量，选择合适的持久化策略。

远程主机强迫关闭了一个现有的连接redis

2024-09-04

这个错误信息表明你尝试与远程主机通信时，远程主机上的Redis服务强制关闭了一个现有的连接。这种情况通常发生在Redis服务器遇到问题，如配置错误、内存不足、达到连接数限制或其他内部错误时。

解决方法：

检查远程Redis服务器的日志文件，以查找为何关闭连接的具体原因。
确认Redis配置文件（通常是redis.conf）中的设置是否正确，如最大连接数、内存限制等。
如果是因为连接数限制，可以在Redis配置文件中增加maxclients的值。
确保远程Redis服务器有足够的内存和处理能力来处理请求。
如果问题依然存在，可以尝试重启Redis服务。
如果你是远程服务器的管理员，可以使用工具如htop或top来监控Redis进程的资源使用情况。
如果你无法解决问题，可以联系远程服务器的管理员或技术支持。

请注意，解决方案取决于具体的错误原因，可能需要对Redis配置进行调整或进行更深入的故障排除。

RedisTemplate 查看key的过期时间

2024-09-04

在Redis中，可以使用TTL命令来查看一个key的过期时间。在Spring框架中，如果你使用的是RedisTemplate或StringRedisTemplate，你可以通过以下方式来获取key的过期时间：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
 
import java.util.concurrent.TimeUnit;
 
@Component
public class RedisService {
 
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
 
    public Long getExpire(String key) {
        return stringRedisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
}

在上面的代码中，getExpire方法接收一个key作为参数，并返回该key的剩余过期时间（单位为秒）。如果key不存在或没有设置过期时间，则返回值为null。如果你想获取其他时间单位的剩余时间，可以在getExpire方法中指定不同的TimeUnit。

Redis-6 三种集群模式：主从模式、哨兵模式、分片集群

2024-09-04

Redis 支持三种集群模式：主从模式、哨兵模式和分片集群模式。

主从模式（Master-Slave Mode）
主从模式是最简单的Redis集群模式。在这种模式下，有一个主节点和一个或多个从节点，主节点用于处理写操作，从节点用于处理读操作。数据是以快照的方式从主节点同步到从节点。




# 配置主节点
redis-server --port 6379

# 配置从节点
redis-server --port 6380 --slaveof 127.0.0.1 6379

哨兵模式（Sentinel Mode）
哨兵模式是主从模式的升级版。它通过哨兵进程监控主节点的健康状态，并在主节点宕机时自动进行故障转移。




# 启动哨兵进程
redis-sentinel /path/to/your/sentinel.conf

分片集群模式（Sharded Cluster Mode）
分片集群模式是最复杂的Redis集群模式，它通过分片机制将数据分布在多个节点上。




# 配置分片集群
redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 --cluster-replicas 1

以上是三种Redis集群模式的简要说明和配置示例。在实际应用中，你需要根据具体需求选择合适的集群模式，并进行相应的配置和管理。