一、引用类型

1、强引用（Strong Reference）

       一般用到最多的是强引用

2、软引用（Soft Reference）

       如果一个对象没有强引用，只有软引用，当JVM发现内存不够时，垃圾回收器便会回收这些对象

3、弱引用（Weak Reference）

       如果一个对象只有弱引用时，每次垃圾回收都会被回收

4、幻影引用（Phantom Reference）

       如果一个对象仅持有幻影引用，那么它就和没有引用指向它一样，在任何时候该对象都可能被垃圾回收器回收。

       幻影引用与软引用和弱引用的区别在于幻影引用必须和引用队列ReferenceQueue一起使用，幻影引用可以用来跟踪对象被回收的活动，因为当垃圾回收器准备回收一个对象的时候，如果发现它还有幻影引用，就会在回收之前，把这个幻影引用加入到与之关联的引用队列中去。

        这样，程序通过判断引用队列中是否已经加入了幻影引用，来了解被引用对象是否将要被垃圾回收器回收，如果发现某个幻影引用已经被加入到引用队列，那么就可以在引用对象被回收之前采取必要的行动。

二、ThreadLocal

1、简介

     ThreadLocal使用了弱引用，在一定程度上可以防止内存泄露。

2、ThreadLocal.ThreadLocalMap

      此map使用的key是经过WeakReference包装的ThreadLocal对象，如果ThreadLocal对象没有其他强引用和弱引用指向时，线程也不会继续持有ThreadLocal对象，根据JVM规范，它会被垃圾回收器在下次回收时被销毁，这在一定程度避免了内存泄露。

 /**     * ThreadLocalMap is a customized hash map suitable only for     * maintaining thread local values. No operations are exported     * outside of the ThreadLocal class. The class is package private to     * allow declaration of fields in class Thread.  To help deal with     * very large and long-lived usages, the hash table entries use     * WeakReferences for keys. However, since reference queues are not     * used, stale entries are guaranteed to be removed only when     * the table starts running out of space.     */    static class ThreadLocalMap {        /**         * The entries in this hash map extend WeakReference, using         * its main ref field as the key (which is always a         * ThreadLocal object).  Note that null keys (i.e. entry.get()         * == null) mean that the key is no longer referenced, so the         * entry can be expunged from table.  Such entries are referred to         * as "stale entries" in the code that follows.         */        static class Entry extends WeakReference
    
      {            /** The value associated with this ThreadLocal. */            Object value;            Entry(ThreadLocal k, Object v) {                super(k);                value = v;            }        }
    

      最好使用remove方法，自己显示释放内存。

三、ThreadLocal应用

（1）ThreadCache

/** * 利用thread local 存取servlet * 每次request的通用数据 * @author caibosi * @created 2014-04-01 */public class ThreadCache {    private static final ThreadLocal
    
      cache = new ThreadLocal
     
      (){        @Override        protected AppThreadContext initialValue() {            return new AppThreadContext();        }    };    private static class AppThreadContext{        String ip;        String userName;        Integer userId;        long startTime;        String hostName;        String logId;        Map
      
        extraData = new ConcurrentHashMap
       
        ();    }    public static void setIp(String ip){        cache.get().ip = ip;    }    public static String getIp(){        return cache.get().ip;    }    public static void setUserName(String userName){        cache.get().userName = userName;    }    public static String getUserName(){        return cache.get().userName;    }    public static void setUserId(Integer userId){        cache.get().userId = userId;    }    public static Integer getUserId(){        return cache.get().userId;    }    public static void setUser(Integer userId,String userName){        cache.get().userId = userId;        cache.get().userName = userName;    }    public static void setExtraData(String key, Object data) {        cache.get().extraData.put(key, data);    }    public static Object getExtraData(String key) {        return cache.get().extraData.get(key);    }    public static void setStartTime(){        cache.get().startTime = System.currentTimeMillis();    }    public static long getStartTime(){        return cache.get().startTime;    }    public static void setLogId(){        String logId = UUID.randomUUID().toString();        cache.get().logId = logId;    }    public static String getLogId(){        return cache.get().logId;    }    public static void setHostName(String hostName){        cache.get().hostName = hostName;    }    public static String getHostName(){        return cache.get().hostName;    }    public static void release() {        cache.remove();    }}
       
      
     
    

    使用及释放：

/** * @author caibosi * @created 2014-04-01 */public class AclInterceptor extends HandlerInterceptorAdapter {    private static final Logger logger = LoggerFactory.getLogger(AclInterceptor.class);    @Resource    private AntPathMatcher antPathMatcher;    @Override    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {        //记录每次访问的时间        ThreadCache.setStartTime();        //记录host        String hostname = null;        try {            hostname = InetAddress.getLocalHost().getHostName();        } catch (UnknownHostException e) {            logger.error(e.getMessage(), e);        }        if (hostname == null) {            hostname = "";        }        ThreadCache.setHostName(hostname);        //url处理        String uri = request.getRequestURI();        // 静态资源不处理        if ("/favicon.ico".equals(uri)                || antPathMatcher.match("/static/**", uri)) {            return super.preHandle(request, response, handler);        }        request.setAttribute("_uri", uri);        // 获取登录用户的ID和用户名信息        //sso或者登录跳转        //debug mode        if(ConfigTool.isDebugEnv()){                ThreadCache.setUserId(ConfigTool.getDebugUserId());        }        //进行权限校验        boolean hasUrlAccess = true;        if(hasUrlAccess == false){            throw new AccessDeniedException("没有访问权限");        }        return super.preHandle(request,response,handler);    }    @Override    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {        super.postHandle(request, response, handler, modelAndView);        String uri = request.getRequestURI().replaceAll(";.*", "");        if (uri.endsWith(".ajax") && (uri.indexOf('.') != -1 || uri.indexOf("/cron/") != -1)) {            return;        }        long time = ThreadCache.getStartTime();        if (time > 0) {            long timeCost = System.currentTimeMillis() - time;            logger.info("time used," + request.getRequestURI() + ",logId:" + ThreadCache.getLogId()                    + "," + timeCost + "ms");            request.setAttribute("_timeCost", timeCost);        }        //thread local资源释放        ThreadCache.release();    }}

（2）事务嵌套

/** * 封装了事务管理操作 * 主要是实现了事务嵌套的管理 * @author caibosi * @created 2013-10-29 */public class TransManager {    private final static Logger logger = LoggerFactory.getLogger(TransManager.class);    private final static ThreadLocal
    
      transLocal = new ThreadLocal
     
      ();    /**     * 设置事务的隔离级别     * @param level     */    public static void setTransactionViolation(TransactionLevel level){        Transaction tran = transLocal.get();        Connection conn = tran.getConn();        try {            conn.setTransactionIsolation(level.getValue());        } catch (SQLException e) {            logger.error("setting transaction violation failed",e);            throw new RuntimeException("setting transaction violation failed",e);        }    }    /**     * 开启事务     */    public static void openTransaction(TransactionLevel level){        Transaction tran = transLocal.get();        if(tran==null){            tran = new Transaction();            Connection conn = DBManager.getConnection();            try {                conn.setAutoCommit(false);                if(level!=null && level.getValue()!= TransactionLevel.getDefault().getValue()){                    conn.setTransactionIsolation(level.getValue());                }            } catch (SQLException e) {                logger.error("open transaction error",e);                throw new RuntimeException("open transaction error");            }            tran.setConn(conn);            tran.setCommitCount(0);            tran.setOpenCount(1);            tran.setCurrentCount(1);            transLocal.set(tran);        } else{            tran.setOpenCount(tran.getOpenCount()+1);            tran.setCurrentCount(tran.getCurrentCount()+1);        }    }    /**     * 提交事务     */    public static void commitTransaction(){        Transaction tran = transLocal.get();        if(tran == null)            throw new RuntimeException("commit transaction , transaction null");        //判断要不要真正提交        if(tran.getCurrentCount()>1){            tran.setCommitCount(tran.getCommitCount() + 1);            tran.setCurrentCount(tran.getCurrentCount()-1);            return;        }        Connection conn = tran.getConn();        if(tran.canReallyCommit()){            try {                conn.commit();            } catch (SQLException e) {                logger.error("commit transaction error",e);                throw new RuntimeException("commit transaction error");            }        }    }    /**     * 回滚事务     * 这里不真正回滚     * 做个标记     * 在close的时候判断是否要回滚     */    public static void rollbackTransaction(){       Transaction tran = transLocal.get();//        if(tran == null){//            logger.info("rollback trans null");//            return;//        }       tran.setCommitCount(0);    }    /**     * 终止事务     */    public static void closeTransaction(){        Transaction tran = transLocal.get();//        if(tran == null){//            logger.info("close trans null");//            return;//        }        //如果当前还有1个以上的事务，不能真正关闭事务        if(tran.getCurrentCount()>1){            tran.setCommitCount(tran.getCurrentCount()-1);            return;        }        //如果只剩一个事务，则真正结束事务，清理变量        Connection conn = tran.getConn();        if(tran.canReallyCommit()==false){            try {                conn.rollback();                logger.info("#### rollback transaction");            } catch (SQLException e) {                logger.error("rollback transaction failed",e);            }finally{                transLocal.remove();                try {                    conn.close();                } catch (SQLException e) {                    logger.error("close conn failed",e);                    throw new RuntimeException("close conn failed",e);                }            }        }    }}/** * 封装了connection * 事务提交次数 * 事务嵌套层次 * 事务开启次数 * 用于控制事务嵌套 * @author caibosi * @created 2013-10-29 */class Transaction {    private Connection conn;    /**     * 统计事务次数     * 每开启一次，增加一次     * 用来与commitCount来判断     * 事务是否全部提交     */    private int openCount;    /**     * 提交次数     * 每提交一次，增加一次     */    private int commitCount;    /**     *  当前的事务数     *  开启一次增加1     *  提交一次减去1     */    private int currentCount;    /**     * 判断是否能够真正提交事务     * @return     */    boolean canReallyCommit(){       return commitCount+1 == openCount;    }    Connection getConn() {        return conn;    }    void setConn(Connection conn) {        this.conn = conn;    }    int getCommitCount() {        return commitCount;    }    void setCommitCount(int commitCount) {        this.commitCount = commitCount;    }    int getOpenCount() {        return openCount;    }    void setOpenCount(int openCount) {        this.openCount = openCount;    }    int getCurrentCount() {        return currentCount;    }    void setCurrentCount(int currentCount) {        this.currentCount = currentCount;    }}