redis資源未釋放引發的問題

一、redis資源未釋放的起因:

N年前,在修改一個古老程序時,不小心把redis釋放的這塊給干掉了,

if (jedis != null) {
    if (!isInProcess) {
        jedis.del(currentPageRunControlRedisKey);
    }
    JedisUtil.getInstance().closeJedis(jedis);
}

 

程序調用了一會之后,就獲取不到redis連接了,異常如下:

redis.clients.jedis.exceptions.JedisConnectionException: Could not get a resource from the pool
	at redis.clients.util.Pool.getResource(Pool.java:42)

 

對比代碼,定位到問題之后,修復上線。

 

二、事后分析出錯的原因：

1、對於redis的認知不足.

2、java從集成redis角度上,我的認知：

2.1、選擇spring-data-redis集成,目前我們的osp框架支持我們用這種方式,我目前的項目在用(po服務化).

        集成后用RedisTemplate即可來操作。

        好處：spring來幫你管理redis的連接獲取和釋放,我們只需要關注自己的業務就好.

        壞處：限制於spring框架,其他暫未感覺...

2.2、用jedis來操作吧,

        自己寫好一個類,來獲取JedisPool,對於redis的操作,記住操作完成后,釋放連接回連接池,否則就會發生,我這次發生的這種問題。

        好處：操作上更加靈活，不限於spring。

        壞處：容易出錯。

 

三、改進：

          對於資源未釋放,想到了在io操作,db操作等情況,最好封裝統一的方法,保證最后資源一定是釋放的。

          redis方面,我參考spring的redisTemplate,

          封裝一個redis工具類,對每種類型的redis操作,封裝一個方法,操作完后將資源釋放回連接池,可避免再忘記釋放redis。

代碼示例：         

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;

/**
 * 描    述：JedisUtil
 * 作    者：瀟邦
 */
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;

    //可用連接實例的最大數目，默認值為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<String, JedisPool> maps = new ConcurrentHashMap<String, JedisPool>();


    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);
            try {
                pool = new JedisPool(config, ip, port, TIMEOUT);
                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 static void main(String[] args) {
        Object val = JedisUtil.getInstance().get("redisKey");
        System.out.println(val);
    }

}

四、redis的概念：

      redis是一個key-value存儲系統。和Memcached類似，它支持存儲的value類型相對更多，包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。這些數據類型都支持push/pop、add/remove及取交集並集和差集及更豐富的操作，而且這些操作都是原子性的。在此基礎上，redis支持各種不同方式的排序。與memcached一樣，為了保證效率，數據都是緩存在內存中。區別的是redis會周期性的把更新的數據寫入磁盤或者把修改操作寫入追加的記錄文件，並且在此基礎上實現了master-slave(主從)同步。

 

五、數據庫連接池的概念：

      數據庫連接池負責分配、管理和釋放數據庫連接，它允許應用程序重復使用一個現有的數據庫連接，而不是再重新建立一個；釋放空閑時間超過最大空閑時間的數據庫連接來避免因為沒有釋放數據庫連接而引起的數據庫連接遺漏。這項技術能明顯提高對數據庫操作的性能。

 

六、參考的資料:

http://www.cnblogs.com/linjiqin/archive/2013/06/14/3135248.html

http://www.sjsjw.com/kf_www/article/70_11941_26800.asp

http://www.cnblogs.com/tankaixiong/p/3660075.html

http://blog.csdn.net/truong/article/details/46711045

http://my.oschina.net/ydsakyclguozi/blog/465859

http://blog.csdn.net/aacm1992/article/details/21977237

http://www.cnblogs.com/jifeng/p/4676863.html