精华内容
下载资源
问答
  • 切换redis后客户端长连接仍旧与旧的服务端保持连接,使用此程序可以从旧的redis服务端断开所有客户端链接。
  • 之前做了一个新闻推荐项目用到redis,当把项目发布到线上去测试的时候,用两个redis的时候发现开始跑的时候没有问题,但是过一段时间当用户访问量特别大的时候有一个redis断开连接的问题,老大采取的解决方案是把...

    之前做了一个新闻推荐项目用到redis,当把项目发布到线上去测试的时候,用两个redis(线上服务采用LVS负载均衡,两个可以切换)的时候发现开始跑的时候没有问题,但是过一段时间当用户访问量特别大的时候有一个redis总断开连接的问题,老大采取的解决方案是把原来一个jedis对象改成10个jedis对象(我觉得应该是模拟了jedispool连接池操作),这样当高并发情况下,这样可以减少redis断开连接的问题,然后生成一个随机数去除以jedis对象得到一个值然后去判断当前redis是否可以使用并添加重连机制

    展开全文
  • 创建一个数组存储redis链接,失效自动创建加入数组, 附上代码一段简单代码,欢迎吐槽 package test; import java.util.Random; import redis.clients.jedis.Jedis; public class RedisArrayUtil { ...

    创建一个数组存储redis链接,失效自动创建加入数组,

     

    附上代码一段简单代码,欢迎吐槽

     

    package test;
    
    import java.util.Random;
    
    import redis.clients.jedis.Jedis;
    
    public class RedisArrayUtil {
        private static Jedis[] jedisArray;
        private static int jedisArraySize;
        private static String jedisHost;
        private static int jedisPort;
        private static Random random = new Random();
    
        private RedisArrayUtil(int jedisArraySize, String jedisHost, int jedisPort) {
            this.jedisArraySize = jedisArraySize;
            this.jedisHost = jedisHost;
            this.jedisPort = jedisPort;
            jedisPool();
        }
    
        @SuppressWarnings("resource")
        public static void jedisPool() {
            jedisArray = new Jedis[jedisArraySize];
            for (int i = 0; i < jedisArraySize; i++) {
                Jedis jedis = new Jedis(jedisHost, jedisPort);
                if (jedis.ping().equals("PONG")) {
                    jedisArray[i] = jedis;
                } else {
                    jedis = new Jedis(jedisHost, jedisPort);
                    jedisArray[i] = jedis;
                }
            }
        }
    
        public Jedis getConnection() {
            int randomCount;
            Jedis jedis;
            while (true) {
                randomCount = random.nextInt(jedisArraySize - 1);
                jedis = jedisArray[randomCount];
                if (jedis.ping().equals("PONG")) {
                    break;
                } else {
                    delete(randomCount, jedisArray);
                    addJedis();
                }
            }
            return jedis;
        }
    
        /** @param 删除数组指定位 */
        public Jedis[] delete(int index, Jedis array[]) {
            Jedis[] jedisArrayNew = new Jedis[array.length - 1];
            for (int i = 0; i < jedisArrayNew.length - 1; i++) {
                if (i < index) {
                    jedisArrayNew[i] = array[i];
                } else {
                    jedisArrayNew[i] = array[i + 1];
                }
            }
            return jedisArrayNew;
        }
    
        public void addJedis() {
            @SuppressWarnings("resource")
            Jedis jedis = new Jedis(jedisHost, jedisPort);
            while (true) {
                if (jedis.ping().equals("PONG")) {
                    jedisArray[jedisArraySize] = jedis;
                    break;
                }
            }
        }
    
        public static void main(String[] args) {
            RedisArrayUtil redisArrayUtil = new RedisArrayUtil(10, "127.0.0.1",
                    6379);
            Jedis jedis = redisArrayUtil.getConnection();
            for (int i = 0; i < 10; i++) {
                System.out.println(redisArrayUtil.getConnection());
            }
            
        }
    }
    

     

    展开全文
  • Redis连接

    2019-10-19 19:00:21
    Redis连接池 Redis 是单进程单线程的,它利用队列技术将并发访问变为串行访问,消除了传统数据库串行控制的开销。 Redis 是基于内存的数据库,使用之前需要建立连接,建立断开连接需要消耗大量的时间。 再假设 Redis...

    Redis连接池

    Redis 是单进程单线程的,它利用队列技术将并发访问变为串行访问,消除了传统数据库串行控制的开销。

    Redis 是基于内存的数据库,使用之前需要建立连接,建立断开连接需要消耗大量的时间。

    再假设 Redis 服务器与客户端分处在异地,虽然基于内存的 Redis 数据库有着超高的性能,但是底层的网络通信却占用了一次数据请求的大量时间,因为每次数据交互都需要先建立连接,假设一次数据交互总共用时 30ms,超高性能的 Redis 数据库处理数据所花的时间可能不到 1ms,也即是说前期的连接占用了 29ms,连接池则可以实现在客户端建立多个连接并且不释放,当需要使用连接的时候通过一定的算法获取已经建立的连接,使用完了以后则还给连接池,这就免去了数据库连接所占用的时间。

    Jedis resource = jedisPool.getResource();
    

    注意,这行代码。我们从 JedisPool 中获取的仅仅是一个连接。至于多个连接到达单进程单线程的 Redis 之后怎么处理,就与线程池无关了。

    实际上,Redis 在收到多个连接后,采用的是非阻塞 IO,基于 epoll 的多路 IO 复用。

    然后采用队列模式将并发访问变为串行访问,对于串行访问,本身操作内存就很快,Redis 采用一个线程来处理就再正常不过了。

    Redis连接池的使用与配置

    在 Java 中使用Redis连接池需要两个 jar 包 commons-pool2-2.4.2.jar 跟 jedis-2.9.0.jar

    配置连接池
    因为连接池中会有很多jedis实例,RedisPool对象会很大,所以我们需要把他写成单例模式,如果是交由Spring管理就不用了,因为Spring管理的Bean默认是单例的。

    // 连接信息
    private static final String HOST = "132.232.6.208";
    private static final int PORT = 6381;
    
    JedisPoolConfig poolConfig = new JedisPoolConfig();
    // 基本配置
    poolConfig.setMaxTotal(1000);           // 最大连接数
    poolConfig.setMaxIdle(32);              // 最大空闲连接数
    poolConfig.setMaxWaitMillis(100*1000);  // 最大等待时间
    poolConfig.setTestOnBorrow(true);       // 检查连接可用性, 确保获取的redis实例可用
                        
    JedisPool jedisPool = new JedisPool(poolConfig, HOST, PORT);
    

    获取连接池连接

    Jedis jedis = jedisPool.getResource();
    

    将连接归还连接池

    jedisPool.returnResourceObject(jedis);  // 已废弃,推荐使用jedis.close()方法
    
    jedis.close()
    

    完整代码

    package com.project.uitl;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    /**
     * Redis 连接池工具包
     * @author wqj24
     *
     */
    public class JedisPoolUtil {
        
        private static final String HOST = "132.232.6.208";
        private static final int PORT = 6381;
        
        private static volatile JedisPool jedisPool = null;
        
        private JedisPoolUtil() {}
        
        /**
         * 获取RedisPool实例(单例)
         * @return RedisPool实例
         */
        public static JedisPool getJedisPoolInstance() {
            if (jedisPool == null) {
                synchronized (JedisPoolUtil.class) {
                    if (jedisPool == null) {
                        
                        JedisPoolConfig poolConfig = new JedisPoolConfig();
                        poolConfig.setMaxTotal(1000);           // 最大连接数
                        poolConfig.setMaxIdle(32);              // 最大空闲连接数
                        poolConfig.setMaxWaitMillis(100*1000);  // 最大等待时间
                        poolConfig.setTestOnBorrow(true);       // 检查连接可用性, 确保获取的redis实例可用
                        
                        jedisPool = new JedisPool(poolConfig, HOST, PORT);
                    }
                }
            }
            
            return jedisPool;
        }
        
        /**
         * 从连接池中获取一个 Jedis 实例(连接)
         * @return Jedis 实例
         */
        public static Jedis getJedisInstance() {
            
            return getJedisPoolInstance().getResource();
        }
        
        /**
         * 将Jedis对象(连接)归还连接池
         * @param jedisPool 连接池
         * @param jedis 连接对象
         */
        public static void release(JedisPool jedisPool, Jedis jedis) {
            
            if (jedis != null) {
                jedisPool.returnResourceObject(jedis);  // 已废弃,推荐使用jedis.close()方法
            }
        }
    }
    

    测试代码

    package com.project.test;
    
    import org.junit.Test;
    
    import com.project.uitl.JedisPoolUtil;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    public class RedisPoolTest {
        
        JedisPool jedisPool = JedisPoolUtil.getJedisPoolInstance();
        
        // 测试单例
        @Test
        public void test01() {
            JedisPool A = JedisPoolUtil.getJedisPoolInstance();
            JedisPool B = JedisPoolUtil.getJedisPoolInstance();
    
            System.out.println(A == B);
        }
        
        @Test
        public void test02() {
            Jedis jedis = null;
            
            try {
                jedis = jedisPool.getResource();  // 获取Redus连接
                
                // 业务
                jedis.set("k1", "v111");
                System.out.println(jedis.get("k1"));
            } finally {
                jedis.close(); // 关闭redis连接
            }
        }
    }
    

    Redis连接池配置及初始化

    加入db选择后的Redis连接池配置代码

    public class RedisPoolConfigure {
    
        //Redis服务器IP
        private String ADDR ;
        
        //Redis的端口号
        private int PORT ;
        
        //可用连接实例的最大数目
        private  int MAX_ACTIVE ;
        
        //pool中的idle jedis实例数
        private  int MAX_IDLE ;
        
        //等待可用连接的最大时间,单位毫秒
        private  int MAX_WAIT ;
        //超时时间,单位毫秒
        private  int TIME_OUT ;
        //设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
        private String EVICTION_POLICY_CLASS_NAME ;
        
        //连接耗尽时是否阻塞, false报异常,ture阻塞直到超时
        private boolean BLOCK_WHEN_EXHAUSTED;
        
        //是否启用pool的jmx管理功能, 默认true
        private boolean JMX_ENABLED;
        
        //在borrow一个jedis实例时,是否提前进行validate操作;如果为true,则得到的jedis实例均是可用的;
        private boolean TEST_ON_BORROW ;
        
        //服务器密码
        private String REDIS_PASS;
        //redis选择数据库DB
        private int REDIS_DB;
        
        
        private String LUASHA;
        
        private  Map<String, String> configure = null;
        
        /**
         * 根据配置文件,将RedisPool连接配置初始化
         */
        public RedisPoolConfigure(){
        	try {
        		configure = new ConfigureReader().readProperties("redis.properties");
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
        	this.ADDR = configure.get("REDIS.ADDR");
        	this.LUASHA = configure.get("REDIS.LUA_HASH");
        	this.EVICTION_POLICY_CLASS_NAME = configure.get("REDIS.EVICTION_POLICY_CLASS_NAME");
        	this.BLOCK_WHEN_EXHAUSTED = Boolean.parseBoolean(configure.get("REDIS.BLOCK_WHEN_EXHAUSTED"));
        	this.JMX_ENABLED = Boolean.parseBoolean(configure.get("REDIS.JMX_ENABLED"));
        	this.TEST_ON_BORROW = Boolean.parseBoolean(configure.get("REDIS.TEST_ON_BORROW"));
        	this.REDIS_PASS=configure.get("REDIS.PASS");
        	
        	if(typeCheck()){
        		this.PORT = new Integer(configure.get("REDIS.PORT"));
        		this.MAX_ACTIVE = new Integer(configure.get("REDIS.MAX_ACTIVE"));
        		this.MAX_IDLE = new Integer(configure.get("REDIS.MAX_IDLE"));
        		this.MAX_WAIT = new Integer(configure.get("REDIS.MAX_WAIT"));
        		this.REDIS_DB=new Integer(configure.get("REDIS.DB"));
        	}else{
        		System.out.println("error");
        	}
        }
        
        /**
         * 辅助工具,检查map中数据的类型
         * @return
         */
    	private boolean typeCheck() {
    		if (isNumeric(configure.get("REDIS.PORT")) 
    				&& isNumeric(configure.get("REDIS.MAX_ACTIVE"))
    				&& isNumeric(configure.get("REDIS.MAX_IDLE")) 
    				&& isNumeric(configure.get("REDIS.MAX_WAIT"))
    				&& isNumeric(configure.get("REDIS.DB"))) {
    			return true;
    		} 
    		return false;
    	}
    
    	public String getADDR() {
    		return ADDR;
    	}
    
    	public int getPORT() {
    		return PORT;
    	}
    
    
    	public int getMAX_ACTIVE() {
    		return MAX_ACTIVE;
    	}
    
    	public int getMAX_IDLE() {
    		return MAX_IDLE;
    	}
    
    	public int getMAX_WAIT() {
    		return MAX_WAIT;
    	}
    
    	public int getTIME_OUT() {
    		return TIME_OUT;
    	}
    
    	public boolean isTEST_ON_BORROW() {
    		return TEST_ON_BORROW;
    	}
    
    	public String getEVICTION_POLICY_CLASS_NAME() {
    		return EVICTION_POLICY_CLASS_NAME;
    	}
    
    	public boolean isBLOCK_WHEN_EXHAUSTED() {
    		return BLOCK_WHEN_EXHAUSTED;
    	}
    
    	public boolean isJMX_ENABLED() {
    		return JMX_ENABLED;
    	}
    	/**
    	 * 判断传入的数据是否为纯数字构成
    	 * @param str
    	 * @return
    	 */
    	public boolean isNumeric(String str) {
    		if(str==null || "".equals(str)){
    			return false;
    		}
    		for (int i = 0; i < str.length(); i++) {
    			if (!Character.isDigit(str.charAt(i))) {
    				return false;
    			}
    		}
    		return true;
    	}
    
    	public String getLUASHA() {
    		return LUASHA;
    	}
    
    	public void setLUASHA(String lUASHA) {
    		LUASHA = lUASHA;
    	}
    
    	public String getREDIS_PASS() {
    		return REDIS_PASS;
    	}
    
    	public void setREDIS_PASS(String rEDIS_PASS) {
    		REDIS_PASS = rEDIS_PASS;
    	}
    
    	public int getREDIS_DB() {
    		return REDIS_DB;
    	}
    
    	public void setREDIS_DB(int rEDIS_DB) {
    		REDIS_DB = rEDIS_DB;
    	}
    }
    

    Redis连接池初始化、获取Jedis实例和释放Jedis实例

    /**
     * jedis的连接池,返回未封装的jedis对象
     * 一般只有在RedisCache类提供的操作粒度不足使用时才使用此类提供的原生jedis方法
     * @author Hector
     *
     */
    public class RedisPool {
    	 
        private static JedisPool jedisPool = null;
        
        /**
         * 初始化Redis连接池
         */
        static {
            try {
            	RedisPoolConfigure configure = new RedisPoolConfigure();
                JedisPoolConfig config = new JedisPoolConfig();
                config.setBlockWhenExhausted(configure.isBLOCK_WHEN_EXHAUSTED());
                config.setEvictionPolicyClassName(configure.getEVICTION_POLICY_CLASS_NAME());
                config.setJmxEnabled(configure.isJMX_ENABLED());
                config.setMaxIdle(configure.getMAX_IDLE());
                config.setMaxTotal(configure.getMAX_ACTIVE());
                config.setMaxWaitMillis(configure.getMAX_WAIT());
                config.setTestOnBorrow(configure.isTEST_ON_BORROW());
                jedisPool = new JedisPool(config, configure.getADDR(), configure.getPORT(), configure.getTIME_OUT(),configure.getREDIS_PASS(),configure.getREDIS_DB());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        /**
         * 获取Jedis实例
         * @return
         */
        public synchronized static Jedis getJedis() {
        	Jedis resource=null;
            try {
                if (jedisPool != null) {
                    resource = jedisPool.getResource();
                    return resource;
                } else {
                    return null;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
        
       
        /**
         * 释放jedis资源
         * @param jedis
         */
    	public static void close(final Jedis jedis) {
            if (jedis != null) {
                jedis.close();
            }
        }
    	
    	public static JedisPool getJedisPool() {
    		return jedisPool;
    	}
    }
    

    参考文章:
    https://www.xttblog.com/?p=3823
    https://www.jianshu.com/p/f7cb5235a892
    https://blog.csdn.net/weixin_38994249/article/details/82774326

    展开全文
  • python redis 断开连接

    千次阅读 2018-07-28 17:44:39
    参考自https://github.com/andymccurdy/redis-py/issues/681 r.connection_pool.disconnect()  

    参考自https://github.com/andymccurdy/redis-py/issues/681

    r.connection_pool.disconnect()

     

    展开全文
  • PyCharm下的Redis连接连接方式: 1. 操作模式redis-py提供两个类Redis和StrictRedis用于实现Redis的命令,StrictRedis用于实现大部分官方的命令,并使用官方的语法和命令,Redis是StrictRedis的子类,用于向后兼容旧...
  • redis集群配置完后,本地linux能正常连接操作,但是换成外部环境,用连接工具连接(Another Redis DeskTop Manager) 一直会出现断开的情况,有时候能连接上。求助大佬帮忙看下。 环境: 自己部署了一个阿里云服务器,...
  • Redis 连接命令介绍

    千次阅读 2018-12-23 15:52:32
    Redis 连接命令主要是用于连接 redis 服务。
  • Redis 连接介绍

    2018-12-24 09:02:00
    redis连接命令介绍 AUTH password 说明:AUTH命令用来检测给定的密码和配置文件中的密码是否相同 返回:如果密码匹配则返回OK,否则返回一个错误 实例: 10.117.8.188:6379&gt; AUTH 1245 //没有设置redis...
  • 首先开启redis的外连sch01ar@ubuntu:~$ sudo vim /etc/redis/redis.conf把bind 127.0.0.1这行注释掉然后重启redissudo /etc/init.d/redis-server restart这样ubuntu的redis本机就可以连接连接并操作# -*- coding:...
  • redis 连接数据库 介绍 (Introduction) Redis is an open-source, in-memory key-value data store. Whether you’ve installed Redis locally or you’re working with a remote instance, you need to connect to ...
  • Redis连接

    2016-08-06 16:26:24
    Redis::__construct 说明: ...实例连接到一个Redis. 参数: Host:string,可以是一个host地址,也可以是一个unix socket port: int timeout: float 秒数,(可选参数,默认值为0代表不限制
  • redis连接

    2021-02-19 22:55:03
    【README】 本文旨在po出 redis连接池的测试用例 <dependencies> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version&...
  • 原先使用jedis的时候,处理手段是在从连接池获取连接时捕获JedisConnectionException异常,在异常处理部分重新获取连接,但是spring data redis似乎不会,如下所示: org.springframework.data.redis....
  • python 关闭redis连接

    千次阅读 2018-12-12 13:36:57
    python读写redis时,到底需不需要关闭redis连接池连接? import redis def RedisUtils(): pool = redis.ConnectionPool(host='172.8.10.145', port=6379, password="xxxxxx", decode_responses=True) ...
  • 错误原因:redis连接池lettuce存在bug 将lettuce干掉 加上jedis 解决办法:更换连接池,使用jedis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>...
  • C# Redis 连接

    2019-09-28 03:41:23
    前面我们已经准备成功开启Redis服务,其端口号为6379,接下来我们就看看如何使用C#语言来操作Redis。就如MongoDB一样,要操作Redis服务,自然就需要下载C#的客户端,这里通过Nuget下载了“ServiceStack.Redis”...
  • 演示Redis连接池JedisPool 连接池 2. 笔者代码中的注释有各种实用说明(当然你觉得注释碍眼可以直接删除): (a).遇到异常及解决方案 (b).一些使用说明 ©.知识点对比与类比 3. 此项目演示需要jedis.jar和commons-...
  • springboot连接redis 项目启动 服务器上redis是开着的 也能连上 redis.conf中绑定本地id也删除了 就是用这个连接池的时候报错 控制台报如下错误: ``` org.springframework.data.redis....
  • (转)python redis 断开连接

    千次阅读 2019-04-22 09:55:05
    参考自https://github.com/andymccurdy/redis-py/issues/681 r.connection_pool.disconnect()
  • redis连接池理解

    2018-11-20 07:38:13
    redis-py使用connection pool来管理对一个redis server的所有连接,避免每次建立、释放连接的开销。默认,每个Redis实例都会维护一个自己的连接池。 可以直接建立一个连接池,然后作为参数Redis,这样就可以实现多个...
  • Redis正常退出

    千次阅读 2018-09-10 18:43:29
    执行如下命令即可正常断开redis连接
  • 场景:while(true) {$r = new Redis();$r->connect(...);$r->auth(...);$r->set(...);$r->get(...);}发现connect会出现大量超过1s的情况,甚至超过3s;但是,如下图抓包所示:两次请求之间间隔了3s才...
  • [tcp://127.0.0.1:6379],经排查是redis连接断开,redis serve配置的timeout时间为300s,中间逻辑处理过久导致 查看Redis服务器配置(默认是不开启的timeout=0,不开启则不会出现上面的问题,为什么要开启请参考:...
  • window下redis连接断开

    千次阅读 2017-09-08 23:15:35
    下载地址https://github.com/dmajkic/redis/downloads安装好之后会出现这样的目录 然后在cmd命令行进入到redis安装...然后进入到redis安装目录下再开一个cmd连接服务端redis-cli.exe 出现下图说明连接成功 退出quit
  • redis连接池之同步

    2018-08-18 21:06:00
    今天国泉分享在项目中redis同步连接池的设计思路,异步方式后面整理好后在上博。 连接池是什么?  国泉的理解是程序在初始化时就建立多个... 1、我们应该有一个redis操作类取名redisClient,他有连接断开re...
  • redis连接大坑

    2018-07-21 09:01:21
    bind 127.0.0.1改成bind 0.0.0.0 网上所说的把bind 127.0.0.1并没有卵用
  • 系统上线运行一段时间之后就会偶尔出现redis连接超时问题,每次重启之后就会解决,由于之前解决过redis连接数问题,所以这次排除这原因 解决过程 1.查看连接数 info clients #Clients connected_clients:***...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,067
精华内容 10,426
关键字:

如何断开redis连接

redis 订阅