redisson的redis连接池大小配置修改方案

最新推荐文章于 2024-05-22 19:40:53 发布
最新推荐文章于 2024-05-22 19:40:53 发布
阅读量2.6k 收藏 2
点赞数 1
文章标签： redis spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42181142/article/details/131132678
版权

1.redisson版本修改成3.10.6

<dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.10.6</version>
        </dependency>

2.添加配置类

package com.scm.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.spring.data.connection.RedissonConnectionFactory;
import org.redisson.spring.starter.RedissonProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.util.ReflectionUtils;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author xiewu
 * @version 1.0
 * @date 2020/8/3 11:38 上午
 */
@Configuration
@ConditionalOnClass({Redisson.class, RedisOperations.class})
@AutoConfigureBefore(RedisAutoConfiguration.class)
@EnableConfigurationProperties({RedissonProperties.class, RedisProperties.class})
public class RedisEnableAutoConfiguration {

    @Autowired
    private RedissonProperties redissonProperties;

    @Autowired
    private RedisProperties redisProperties;

    @Autowired
    private ApplicationContext ctx;

    @Bean
    public RedisSerializer<String> redisKeySerializer() {
        return RedisSerializer.string();
    }

    @Bean
    public RedisSerializer<Object> redisValueSerializer() {
        return RedisSerializer.json();
    }

    /**
     * RedisTemplate配置
     * @param factory
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory
            , RedisSerializer<String> redisKeySerializer, RedisSerializer<Object> redisValueSerializer) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);

        redisTemplate.setDefaultSerializer(redisValueSerializer);
        redisTemplate.setKeySerializer(redisKeySerializer);
        redisTemplate.setHashKeySerializer(redisKeySerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    @ConditionalOnMissingBean(RedisConnectionFactory.class)
    public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
        return new RedissonConnectionFactory(redisson);
    }

    @Bean(destroyMethod = "shutdown")
    @ConditionalOnMissingBean(RedissonClient.class)
    public RedissonClient redisson() throws IOException {
        Config config = null;
        Method clusterMethod = ReflectionUtils.findMethod(RedisProperties.class, "getCluster");
        Method timeoutMethod = ReflectionUtils.findMethod(RedisProperties.class, "getTimeout");
        Object timeoutValue = ReflectionUtils.invokeMethod(timeoutMethod, redisProperties);
        int timeout;
        if(null == timeoutValue){
            timeout = 0;
        }else if (!(timeoutValue instanceof Integer)) {
            Method millisMethod = ReflectionUtils.findMethod(timeoutValue.getClass(), "toMillis");
            timeout = ((Long) ReflectionUtils.invokeMethod(millisMethod, timeoutValue)).intValue();
        } else {
            timeout = (Integer)timeoutValue;
        }

        if (redissonProperties.getConfig() != null) {
            try {
                InputStream is = getConfigStream();
                config = Config.fromJSON(is);
            } catch (IOException e) {
                // trying next format
                try {
                    InputStream is = getConfigStream();
                    config = Config.fromYAML(is);
                } catch (IOException e1) {
                    throw new IllegalArgumentException("Can't parse config", e1);
                }
            }
        } else if (redisProperties.getSentinel() != null) {
            Method nodesMethod = ReflectionUtils.findMethod(RedisProperties.Sentinel.class, "getNodes");
            Object nodesValue = ReflectionUtils.invokeMethod(nodesMethod, redisProperties.getSentinel());

            String[] nodes;
            if (nodesValue instanceof String) {
                nodes = convert(Arrays.asList(((String)nodesValue).split(",")));
            } else {
                nodes = convert((List<String>)nodesValue);
            }

            config = new Config();
            config.useSentinelServers()
                    .setMasterName(redisProperties.getSentinel().getMaster())
                    .addSentinelAddress(nodes)
                    .setDatabase(redisProperties.getDatabase())
                    .setConnectTimeout(timeout)
                    .setPassword(redisProperties.getPassword());
        } else if (clusterMethod != null && ReflectionUtils.invokeMethod(clusterMethod, redisProperties) != null) {
            Object clusterObject = ReflectionUtils.invokeMethod(clusterMethod, redisProperties);
            Method nodesMethod = ReflectionUtils.findMethod(clusterObject.getClass(), "getNodes");
            List<String> nodesObject = (List) ReflectionUtils.invokeMethod(nodesMethod, clusterObject);

            String[] nodes = convert(nodesObject);

            config = new Config();
            config.useClusterServers()
                    .addNodeAddress(nodes)
                    .setConnectTimeout(timeout)
                    .setPassword(redisProperties.getPassword());
        } else {
            config = new Config();
            String prefix = "redis://";
            Method method = ReflectionUtils.findMethod(RedisProperties.class, "isSsl");
            if (method != null && (Boolean)ReflectionUtils.invokeMethod(method, redisProperties)) {
                prefix = "rediss://";
            }

            RedisProperties.Pool pool = redisProperties.getLettuce().getPool() == null ? redisProperties.getJedis().getPool() :redisProperties.getLettuce().getPool();
            pool = pool == null ? new RedisProperties.Pool() : pool;
            config.useSingleServer()
                    .setAddress(prefix + redisProperties.getHost() + ":" + redisProperties.getPort())
                    .setConnectTimeout(timeout)
                    .setDatabase(redisProperties.getDatabase())
                    .setPassword(redisProperties.getPassword())
                    .setConnectionPoolSize(pool.getMaxIdle())//连接池最大容量
                    .setConnectionMinimumIdleSize(pool.getMinIdle());//最小空闲连接数
        }

        return Redisson.create(config);
    }

    private String[] convert(List<String> nodesObject) {
        List<String> nodes = new ArrayList<String>(nodesObject.size());
        for (String node : nodesObject) {
            if (!node.startsWith("redis://") && !node.startsWith("rediss://")) {
                nodes.add("redis://" + node);
            } else {
                nodes.add(node);
            }
        }
        return nodes.toArray(new String[nodes.size()]);
    }

    private InputStream getConfigStream() throws IOException {
        Resource resource = ctx.getResource(redissonProperties.getConfig());
        InputStream is = resource.getInputStream();
        return is;
    }
}

下面的RedissonAutoConfiguration和RedisAutoConfiguration类是源码中的代码，这里的RedisAutoConfiguration引入了@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })两个类，这两个类注入了LettuceConnectionFactory和RedissonConnectionFactory类，这两个类都实现了RedisConnectionFactory接口，因为LettuceConnectionFactory先注入，所以导致默认使用了LettuceConnectionFactory连接工程，所以我们自己写了一个RedisEnableAutoConfiguration，然后到这里先注入RedissonConnectionFactory这样的话就会使用这个连接工厂，然后到redisson中添加setConnectionPoolSize(pool.getMaxIdle())和setConnectionMinimumIdleSize(pool.getMinIdle())这样redisson的连接池初始化大小就能使用到下面yaml的参数配置了

redis连接池参数配置

spring:
  redis:
    host: xxx # Redis服务器地址
    database: 0 # Redis数据库索引（默认为0）
    port: 6379 # Redis服务器连接端口
    password: xxx # Redis服务器连接密码（默认为空）
    jedis:
      pool:
        max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
        max-wait: -1ms # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 8 # 连接池中的最大空闲连接
        min-idle: 5 # 连接池中的最小空闲连接
    timeout: 3000ms # 连接超时时间（毫秒）

/**
 * Copyright 2018 Nikita Koksharov
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.redisson.spring.starter;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.spring.data.connection.RedissonConnectionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Sentinel;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.util.ReflectionUtils;

/**
 * 
 * @author Nikita Koksharov
 *
 */
@Configuration
@ConditionalOnClass(Redisson.class)
@AutoConfigureAfter(RedisAutoConfiguration.class)
@EnableConfigurationProperties(RedissonProperties.class)
public class RedissonAutoConfiguration {

    @Autowired
    private RedissonProperties redissonProperties;
    
    @Autowired
    private RedisProperties redisProperties;
    
    @Autowired
    private ApplicationContext ctx;
    
    @Bean
    @ConditionalOnMissingBean(RedisConnectionFactory.class)
    public RedissonConnectionFactory redissonConnectionFactory(RedissonClient redisson) {
        return new RedissonConnectionFactory(redisson);
    }
    
    @Bean(destroyMethod = "shutdown")
    @ConditionalOnMissingBean(RedissonClient.class)
    public RedissonClient redisson() throws IOException {
        Config config = null;
        Method clusterMethod = ReflectionUtils.findMethod(RedisProperties.class, "getCluster");
        Method timeoutMethod = ReflectionUtils.findMethod(RedisProperties.class, "getTimeout");
        Object timeoutValue = ReflectionUtils.invokeMethod(timeoutMethod, redisProperties);
        int timeout;
        if(null == timeoutValue){
            timeout = 0;
        }else if (!(timeoutValue instanceof Integer)) {
            Method millisMethod = ReflectionUtils.findMethod(timeoutValue.getClass(), "toMillis");
            timeout = ((Long) ReflectionUtils.invokeMethod(millisMethod, timeoutValue)).intValue();
        } else {
            timeout = (Integer)timeoutValue;
        }
        
        if (redissonProperties.getConfig() != null) {
            try {
                InputStream is = getConfigStream();
                config = Config.fromJSON(is);
            } catch (IOException e) {
                // trying next format
                try {
                    InputStream is = getConfigStream();
                    config = Config.fromYAML(is);
                } catch (IOException e1) {
                    throw new IllegalArgumentException("Can't parse config", e1);
                }
            }
        } else if (redisProperties.getSentinel() != null) {
            Method nodesMethod = ReflectionUtils.findMethod(Sentinel.class, "getNodes");
            Object nodesValue = ReflectionUtils.invokeMethod(nodesMethod, redisProperties.getSentinel());
            
            String[] nodes;
            if (nodesValue instanceof String) {
                nodes = convert(Arrays.asList(((String)nodesValue).split(",")));
            } else {
                nodes = convert((List<String>)nodesValue);
            }
            
            config = new Config();
            config.useSentinelServers()
                .setMasterName(redisProperties.getSentinel().getMaster())
                .addSentinelAddress(nodes)
                .setDatabase(redisProperties.getDatabase())
                .setConnectTimeout(timeout)
                .setPassword(redisProperties.getPassword());
        } else if (clusterMethod != null && ReflectionUtils.invokeMethod(clusterMethod, redisProperties) != null) {
            Object clusterObject = ReflectionUtils.invokeMethod(clusterMethod, redisProperties);
            Method nodesMethod = ReflectionUtils.findMethod(clusterObject.getClass(), "getNodes");
            List<String> nodesObject = (List) ReflectionUtils.invokeMethod(nodesMethod, clusterObject);
            
            String[] nodes = convert(nodesObject);
            
            config = new Config();
            config.useClusterServers()
                .addNodeAddress(nodes)
                .setConnectTimeout(timeout)
                .setPassword(redisProperties.getPassword());
        } else {
            config = new Config();
            String prefix = "redis://";
            Method method = ReflectionUtils.findMethod(RedisProperties.class, "isSsl");
            if (method != null && (Boolean)ReflectionUtils.invokeMethod(method, redisProperties)) {
                prefix = "rediss://";
            }
            
            config.useSingleServer()
                .setAddress(prefix + redisProperties.getHost() + ":" + redisProperties.getPort())
                .setConnectTimeout(timeout)
                .setDatabase(redisProperties.getDatabase())
                .setPassword(redisProperties.getPassword());
        }
        
        return Redisson.create(config);
    }

    private String[] convert(List<String> nodesObject) {
        List<String> nodes = new ArrayList<String>(nodesObject.size());
        for (String node : nodesObject) {
            if (!node.startsWith("redis://") && !node.startsWith("rediss://")) {
                nodes.add("redis://" + node);
            } else {
                nodes.add(node);
            }
        }
        return nodes.toArray(new String[nodes.size()]);
    }

    private InputStream getConfigStream() throws IOException {
        Resource resource = ctx.getResource(redissonProperties.getConfig());
        InputStream is = resource.getInputStream();
        return is;
    }

    
}

/*
 * Copyright 2012-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.boot.autoconfigure.data.redis;

import java.net.UnknownHostException;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

/**
 * {@link EnableAutoConfiguration Auto-configuration} for Spring Data's Redis support.
 *
 * @author Dave Syer
 * @author Andy Wilkinson
 * @author Christian Dupuis
 * @author Christoph Strobl
 * @author Phillip Webb
 * @author Eddú Meléndez
 * @author Stephane Nicoll
 * @author Marco Aust
 * @author Mark Paluch
 * @since 1.0.0
 */
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

}
weixin_42181142
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
go语言操作redis连接池的方法
09-10
在Go语言中，Redis连接池的管理是通过`redis.Pool`结构体来实现的，它提供了高效的连接复用，能够显著提升程序的性能。本文将详细介绍如何使用Go语言操作Redis连接池，以及其中涉及到的关键技术和注意事项。 首先，...
redisson配置类---SpringBoot集成、redis单机和集群模式配置
Harden_zsc的博客
08-14 4812
【代码】redisson配置类---SpringBoot集成、redis单机和集群模式配置。
SpringBoot集成redisson操作redis
quanzhan_King的博客
05-31 6149
该对象的最大容量受Redis限制，最大元素数量是4294967295个。基于Redisson的分布式Set结构的RSet Java对象实现了java.util.Set接口，通过元素的互相状态比较保证了每个元素的唯一性，该对象的最大容量受Redis限制，最大元素数量是4294967295个。基于Redisson的分布式列表 List 结构的RList Java对象在实现了java.util.List接口的同时，确保了元素插入时的顺序，该对象的最大容量受Redis限制，最大元素数量是4294967295个。
Redisson的setConnectionMinimumIdleSize配置，设置小一点有什么影响？
最新发布
良月柒
05-22 728
设置为 3 意味着将保持至少 3 个空闲连接。这可以在一定程度上减少连接建立的开销，提高响应速度，但同时也会占用一些系统资源。最佳的设置值需要根据应用的具体负载情况和资源情况进行调整和优化。通过监控、测试和调整，可以找到一个平衡点，既能提高性能，又不会浪费资源。
【征服redis5】redis的Redisson客户端
纵横千里 捭阖四方 的专栏
01-16 1819
Redisson 最初由 GitHub 用户 “mrniko” 创建，并在 Apache 2.0 许可证下发布。它的目标是提供一组强大的工具和 API，帮助开发人员在分布式环境中处理数据，并解决并发和一致性的问题。Redisson 是一款在 Redis 的基础上实现的 Java 驻内存数据网格（In-Memory Data Grid）。它提供了很多分布式的java对象并直接映射到Redis服务器的数据结构。
Java Redisson多集群连接
mmmmmmmmo的博客
12-26 2393
Java项目需要使用Redisson同时连接多个Redis集群，可参考本文代码
SpringBoot--配置Redisson的方法
热门推荐
IT利刃出鞘的博客
09-14 1万+
本文介绍如何在SpringBoot中配置Redisson。
基于Redis的分布式锁，Redisson的简单使用和常用配置
魑魅魍魉
05-17 2073
Redisson是一个在Redis基础上实现的Java驻内存数据网格。Redisson提供了使用Redis的最简单最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中的放在处理业务逻辑上。
Redisson 的高级功能
洪晓鸿
04-07 779
Redisson 提供了对 Redis 集群的支持，但它的主要优势在于它的高级功能，如分布式锁、分布式对象、分布式集合等。这些功能需要对 Redis 集群中的多个节点进行操作，并且需要保证数据的一致性和可靠性。为了实现这些功能，Redisson 使用了多个 Redis 节点之间的协调和通信机制，并提供了丰富的配置选项，以便根据实际需求进行配置
Redisson的配置
qq_44861126的博客
04-23 4305
【代码】Redisson的配置。
redis工具类以及redis 连接池配置
07-01
创建jedis池配置实例，redis各种crud方法，包括使用主从同步，读写分离。工具类中包括存放hash表键值对，键值对以map的方式储存，删除键值对，永久存放键值对，设置过期时间，需要的直接去gitHab上看...
Spring mvc整合redis实例(redis连接池)
09-19
Spring mvc整合redis实例(redis连接池) 将所有jedis 增删改进行事务的封装、查询单独做为有返回参数的封装。简化了很多代码
redis连接池
02-17
Redis连接池：里面是针对ecmall框架的Redis连接池。
一个简单的支持多个db的redis连接池
04-18
一个简单的支持多个db的redis连接池一个简单的支持多个db的redis连接池一个简单的支持多个db的redis连接池一个简单的支持多个db的redis连接池一个简单的支持多个db的redis连接池一个简单的支持多个db的redis连接池一...
springboot 池化 redis?
洪晓鸿
04-17 307
可以在Spring Boot应用中使用Redisson连接池来执行Redis操作。请注意，根据您的实际需求，可以使用更多的Redisson API来操作Redis的其他数据结构和功能。通过以上步骤，您可以在Spring Boot中配置Redisson连接池。在Spring Boot中使用Redisson时，可以通过配置文件来设置连接池参数。在Spring Boot中配置了Redisson连接池后，您可以在需要使用Redis的地方注入。在此文件中，您可以配置Redisson的连接池参数。
【入门篇】1.6 redis 客户端 之Redisson详解
日拱一卒无有尽，功不唐捐终入海
09-10 1031
Redisson 最初由 GitHub 用户 “mrniko” 创建，并在 Apache 2.0 许可证下发布。它的目标是提供一组强大的工具和 API，帮助开发人员在分布式环境中处理数据，并解决并发和一致性的问题。Redisson 是一款在 Redis 的基础上实现的 Java 驻内存数据网格（In-Memory Data Grid）。它提供了很多分布式的java对象并直接映射到Redis服务器的数据结构。
Redission配置参数说明（*）
weixin_42408447的博客
07-18 2394
redission配置
Redission的使用
weixin_62108279的博客
05-19 766
【代码】Redission的使用。
Redisson锁功能、使用场景、注意事项
u014203449的博客
06-09 2907
举例：方法a加锁用的是trylock，即可能加锁失败，方法b的业务也就可能失败，但如果方法c的业务一定要成功，那方法c就可以提前加锁用 lock方法，再调用方法a时加锁肯定成功，这样保证了方法c和a一定能成功。3.谨慎使用leaseTime参数，设置后watchdog不生效，到了leaseTime后、即使业务没执行结束，锁也会释放，如果此时其他线程加锁，可能造成线程不安全。举例场景：封装了方法a，其中加锁了，方法b通过调用a完成业务，方法c也调用a，但方法c在调用a前已经加锁。如果为0，则是不等待。
redis连接池配置
09-06
要配置 Redis 连接池，你需要在 Redis 的配置文件中进行相应的设置。以下是一个示例配置： ``` # 最大连接数 maxclients 1000 # 连接池大小 # 如果设置为 0，则表示不使用连接池 # 如果设置为负数，则表示使用无限制的连接池 # 如果设置为正数，则表示连接池的大小 maxmemory 256mb # 设置连接池超时时间（单位：秒） timeout 30 # 开启 TCP KeepAlive 选项 tcp-keepalive 300 # 设置连接闲置超时时间（单位：秒） # 如果一个连接在指定的时间内没有进行任何操作，则会被关闭 tcp-keepalive-interval 60 # 开启 TCP NoDelay 选项 tcp-nodelay yes # 开启 TCP QuickAck 选项 tcp-quickack yes # 开启 SO_REUSEADDR 选项 tcp-reuseaddr yes # 开启 SO_KEEPALIVE 选项 tcp-keepalive yes # 开启 TCP_NODELAY 和 TCP_KEEPALIVE 选项 reliable yes # 设置连接池中连接的最大闲置时间（单位：秒） # 如果一个连接在指定的时间内没有被使用，则会被关闭 timeout 600 # 开启 TCP 连接复用（将多个请求复用到一个 TCP 连接）的选项 tcp-keepalive 300 # 设置连接复用的时间间隔（单位：毫秒） tcp-keepalive-interval 1000 # 开启单个连接的多个命令请求模式，以提高性能 # 该模式将多个命令一起发送到服务器，然后一起接收响应 # 但是需要注意的是，如果一个命令的执行时间过长，可能会导致后续命令的阻塞 # 默认情况下，该选项是关闭的 repl-disable-tcp-nodelay no ``` 你可以根据需要进行相应的调整和修改，然后将配置文件保存并重新启动 Redis 服务，新的配置将生效。记得备份原有的配置文件以防出现问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值