JAVA-redis报错:JedisConnectionException: Could not get a resource from the pool

redis.clients.jedis.exceptions.JedisConnectionException: Could not get a resource from the pool
        at redis.clients.util.Pool.getResource(Pool.java:53)
        at redis.clients.jedis.JedisPool.getResource(JedisPool.java:226)
                ...................
Caused by: redis.clients.jedis.exceptions.JedisConnectionException: java.net.SocketTimeoutException: connect timed out
                ...................
Caused by: java.net.SocketTimeoutException: connect timed out

网上能搜到的解决方法无非分为以下几个:

Redis没有启动,需要启动redis:我的不是这个原因,使用RedisDesktopManager工具连接正常。
防火墙、安全组没有关闭:防火墙压根没开过、安全组早已经把6379端口开放了。
IP地址或端口错误:查看以下程序中写的自己云服务器的IP和端口,没问题。
Jedis 对象用完以后未释放掉,池中无可用资源,所以会出现无法获取新的资源。

网上说,客户端去redis服务器拿连接的时候,池中无可用连接,即池中所有连接被占用,且在等待时候设定的超时时间后还没拿到时,报出此异常。 解决办法:调整JedisPoolConfig中maxActive为适合自己系统的阀值。

网上一篇博客中提到:如果你用的jedis 2.4.2以及以前版本,用完之后别忘了return连接到资源池。不过2.5.0版本之后,jedis使用了try-with-resource,jedis用完了就会自动归还了,不用每次都自己return了。相应的他还给出了一个完整的,带有return资源到连接池的Jedis工具类,我一想,我使用的Jedis版本是2.8.0啊,按他说的讲道理jedis用完了就会自动归还了,我就把我之前的工具类给替换掉了。不过他写的这个工具类确实挺好的,后面一直使用的也是这个,我贴到下面哈:

 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * @说明: Redis操作工具类
 * @return
 * @author:Jeremiah Yu
 * @date 2019/3/5 11:36
 */
public class JedisUtil {
 
    private static final Log logger = LogFactory.getLog(JedisUtil.class);
 
    //Redis服务器IP
    private static String IP = "127.0.0.1";
 
    //Redis的端口号
    private static int PORT = 6379;
 
    //Redis服务密码
    private static String password = "******";
 
    //可用连接实例的最大数目,默认值为8;
    //如果赋值为-1,则表示不限制;如果pool已经分配了maxActive个jedis实例,则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 64;
 
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例,默认值也是8。
    private static int MAX_IDLE = 20;
 
    //等待可用连接的最大时间,单位毫秒,默认值为-1,表示永不超时。如果超过等待时间,则直接抛出JedisConnectionException;
    private static int MAX_WAIT = 3000;
 
    private static int TIMEOUT = 3000;
 
    //在borrow一个jedis实例时,是否提前进行validate操作;如果为true,则得到的jedis实例均是可用的;
    private static boolean TEST_ON_BORROW = true;
 
    //在return给pool时,是否提前进行validate操作;
    private static boolean TEST_ON_RETURN = true;
 
    private static Map maps = new ConcurrentHashMap();
 
    private JedisUtil() {
    }
 
    /**
     * 类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例 没有绑定关系,而且只有被调用到时才会装载,从而实现了延迟加载。
     */
    private static class RedisUtilHolder {
        private static JedisUtil instance = new JedisUtil();
    }
 
    /**
     * 当getInstance方法第一次被调用的时候,它第一次读取 RedisUtilHolder.instance,导致RedisUtilHolder类得到初始化;
     * 而这个类在装载并被初始化的时候,会初始化它的静态域,从而创建RedisUtil的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,
     * 并由虚拟机来保证它的线程安全性。 这个模式的优势在于,getInstance方法并没有被同步,
     * 并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。
     */
    public static JedisUtil getInstance() {
        return RedisUtilHolder.instance;
    }
 
    /**
     * 获取连接池.
     */
    private JedisPool getPool(String ip, int port) {
        String key = ip + ":" + port;
        JedisPool pool = null;
        if (!maps.containsKey(key)) {//根据ip和端口判断连接池是否存在.
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            config.setTestOnReturn(TEST_ON_RETURN);
 
            //false:如果连接池没有可用Jedis连接,立即抛出异常;默认true时:如果连接池没有可用Jedis连接,
            //会等待maxWaitMillis(毫秒),依然没有获取到可用Jedis连接
            //config.setBlockWhenExhausted(false);
 
            try {
                pool = new JedisPool(config, ip, port, TIMEOUT,password);
                maps.put(key, pool);
            } catch (Exception e) {
                logger.error("初始化Redis连接池异常:", e);
            }
        } else {
            pool = maps.get(key);
        }
        return pool;
    }
 
    /**
     * 获取Jedis实例
     */
    public Jedis getJedis() {
        Jedis jedis = null;
        try {
            jedis = getPool(IP, PORT).getResource();
        } catch (Exception e) {
            logger.error("获取Jedis实例异常:", e);
            // 销毁对象
            getPool(IP, PORT).returnBrokenResource(jedis);
        }
        return jedis;
    }
 
    /**
     * 释放jedis资源到连接池
     */
    public void returnResource(final Jedis jedis) {
        if (jedis != null) {
            getPool(IP, PORT).returnResource(jedis);
        }
    }
 
    /**
     * 获取数据
     */
    public Object get(String key) {
        Object value = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            value = jedis.get(key);
        } catch (Exception e) {
            logger.warn("获取数据异常:", e);
        } finally {
            //返还到连接池
            returnResource(jedis);
        }
        return value;
    }
 
    //设置数据
    public boolean set(String key,String value){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.set(key,value);
            return true;
        }catch (Exception e){
            logger.warn("设置数据异常",e);
            return false;
        }finally {
            //返还到连接池
            returnResource(jedis);
        }
    }
 
    //删除数据
    public void delete(String key){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            jedis.del(key);
        }catch (Exception e){
            logger.warn("删除数据异常",e);
        }finally {
            //返还到连接池
            returnResource(jedis);
        }
    }
 
    public static void main(String[] args) {
        JedisUtil.getInstance().set("lp","yuzhsaneh");
        Object val = JedisUtil.getInstance().get("lp");
        System.out.println(val);
    }
}

连接池参数blockWhenExhausted = true(默认)如果连接池没有可用Jedis连接,会等待maxWaitMillis(毫秒),如果依然没有获取到可用Jedis连接,会抛出如下异常:

redis.clients.jedis.exceptions.JedisConnectionException: Could not get a resource from the pool
    …
Caused by: java.util.NoSuchElementException: Timeout waiting for idle object
    at org.apache.commons.pool2.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:449)

连接池参数blockWhenExhausted = false;设置该参数,如果连接池没有可用的Jedis连接,立即抛出异常:

redis.clients.jedis.exceptions.JedisConnectionException: Could not get a resource from the pool
    …
Caused by: java.util.NoSuchElementException: Pool exhausted
    at org.apache.commons.pool2.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:464)

上述异常是客户端没有从连接池(最大数量maxTotal)获得可用的Jedis连接造成的,可能有如下原因:

(1) 连接泄露:JedisPool默认的maxTotal=8,下面的代码从JedisPool中获取了8个Jedis资源,但是没有归还资源,当第9次尝试获取Jedis资源的时候,无法获得(jedisPool.getResource().ping())(我已经换成了别人写好的Redis工具类,别人封装的很好了啊,用完就放回资源池里,这种情况可以排除)

(2) 业务并发量大,maxTotal设置得过小了。(我的项目压根就没有上线,不存在什么并发)

(3) Jedis连接阻塞:例如Redis发生了阻塞(例如慢查询等原因),所有连接在超时时间范围内等待,并发量较大时,会造成连接池资源不足。(我重新安装过Redis,第一次连接也是同样的问题,所以这种情况也可以排除)

你可能感兴趣的:(redis,服务器)