Comment résoudre l'erreur de fuite de mémoire causée par l'utilisation de lettuce pour démarrer Redis

Redis utilise de la laitue.

LEAK : haschedwheelTimer.release() n'a pas été appelé avant d'être récupéré. Activer la fuite avancée

Fuite de mémoire. En fait, cela est dû à une mémoire insuffisante.

Recherchez la fenêtre->préférences->Java->JRE installé dans eclispe, cliquez sur le bouton Modifier à droite et remplissez les valeurs suivantes dans l'option "Arguments de la VM par défaut" dans l'interface d'édition.

-Xms64m -Xmx128m

La mémoire peut être ajustée pour être suffisamment grande.

L'autre méthode ne fonctionne pas. Je ne sais pas s'il s'agit d'un problème avec des paramètres de méthode incorrects

1. Ouvrez le fichier de configuration Eclipse Eclipse.ini et modifiez -Xmx (la valeur représente la quantité maximale de mémoire que le jvm peut utiliser)

2. exécutez le programme Java, sélectionnez run-> ;run configuration->arguments, entrez -Xms100M -Xmx800M (-Xms représente la taille de mémoire allouée au démarrage de la machine virtuelle Java et -Xmx représente la quantité maximale de mémoire pouvant être allouée).

Supplément : pool de connexion Redis Record de pièges de laitue

1. Introduction

Récemment, nous avons fréquemment déployé des projets dans différents environnements de test, mais avons rencontré de nombreux problèmes Redis pendant le processus de construction et de déploiement. Le projet est basé sur SpringBoot2.1.12. Le package jar intégré SpringBoot2.1.X Spring-data-redis-start utilise Lettuce comme pool de connexion Redis.

SpringBoot1.x utilise Jedis comme pool de connexions client Redis par défaut.

SpringBoot2.x, spring-data-redis utilise Lettuce comme pool de connexions de pilote client Redis par défaut.

2. Scénario piège

Un nœud maître dans le cluster Redis de l'environnement en cours d'exécution est instable et ne peut pas être connecté, ce qui entraîne le signalement par l'application SpringBoot d'une erreur lors de la connexion à Redis et d'une erreur de délai de connexion.

3. Solution

Réécrivez le bean RedisConnectionFactory, basé sur Spring-data-redis. Vous devez définir « Annuler la vérification de l'appartenance au nœud du cluster » : .validateClusterNodeMembership(false).

1. configuration redis

spring:
 redis:
   cluster:
     nodes:
     - ${redis.host.cluster} #redis集群ip-port
   password: ${redis.password}
   timeout: 5000 #连接超时时间
   lettuce:
     pool:
       max-active: 10 #连接池最大连接数
       max-wait: -1 #连接池最大阻塞时间
       max-idle: 5 #连接池中最大空闲连接
       min-idle: 1 #连接池中最小空闲连接
redis:
 cluster:
   enabled: true

2. Classe de configuration de configuration

@Data
@Component
@ConditionalOnProperty(name = "redis.cluster.enabled", havingValue = "true", matchIfMissing = false)
public class RedisConfig {
    @Autowired
    RedisProperties redisProperties;
    // 在构建LettuceConnectionFactory时，如果不使用内置的destroyMethod，可能会导致Redis连接早于其它Bean被销毁
    @Bean(destroyMethod = "destroy")
    public RedisConnectionFactory newLettuceConnectionFactory() {
        // 配置用于开启自适应刷新和定时刷新。如自适应刷新不开启，Redis集群变更时将会导致连接异常
        ClusterTopologyRefreshOptions clusterTopologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
                .enablePeriodicRefresh(Duration.ofSeconds(60))// 开启周期刷新(默认60秒)
                .enableAdaptiveRefreshTriggers(RefreshTrigger.ASK_REDIRECT,RefreshTrigger.UNKNOWN_NODE)// 开启自适应刷新
                .build();
        ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()
                                 .topologyRefreshOptions(clusterTopologyRefreshOptions)//拓扑刷新
                                 .disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
                                 .autoReconnect(true)
                                 .socketOptions(SocketOptions.builder().keepAlive(true).build())
　　　　　　　　　　　　　　　　       .validateClusterNodeMembership(false)// 取消校验集群节点的成员关系
                                 .build();
        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
                .clientOptions(clusterClientOptions)
                                .readFrom(ReadFrom.SLAVE_PREFERRED)
                                .build();
        return new LettuceConnectionFactory(getClusterConfiguration(), clientConfig);
    }
    
    private  RedisClusterConfiguration getClusterConfiguration() {
        RedisProperties.Cluster clusterProperties = redisProperties.getCluster();
        RedisClusterConfiguration config = new RedisClusterConfiguration(clusterProperties.getNodes());
        if (clusterProperties.getMaxRedirects() != null) {
            config.setMaxRedirects(clusterProperties.getMaxRedirects());
        }
        if (redisProperties.getPassword() != null) {
            config.setPassword(RedisPassword.of(redisProperties.getPassword()));
        }
        return config;
    }
}

Remarque :

RedisClusterConfiguration getClusterConfiguration() doit définir un mot de passe, sinon SpringBoot signalera une erreur d'authentification au démarrage :

"io.lettuce. core.RedisCommandExecut ionException : Authentification NOAUTH requise »

est la suivante :

De plus, la version du package jar lettuce-core ne peut pas être trop basse pour empêcher la prise en charge de certains éléments de configuration. La configuration ci-dessus est lettuce-core-5.18. .RELEASE.jar.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!