专注于分享Java后端相关技术、老司机实战干货，不限于JVM、并发、设计模式、性能优化、分布式&微服务、云原生、大数据相关主题。
希望关注的你停下脚步，定有所收获。

以前的个人博客内容不好迁移，所以我打算根据自己的多年经验，不断整理输出有价值的内容。
目前公众号内容有关于SpringCloud（微服务框架）、Skywalking（APM监控调用链）、JVM（GC分析、内存泄漏分析）、并发编程相关原创实战文章已出炉。

最近刚开始已经有不少小伙伴关注了，期待能有幸搜索到本博客的同学，可以扫码关注一下，不胜感激。
大家有任何技术、职场、面试上的问题都可以与我交流。

方式一：扫码以下公众号二维码：


方式二：在微信上直接搜索： javatech_cbo

感谢各位小伙伴的支持，后续会在该公众号上输出大量的有价值的实战干货 ，期待与你一同进步与成长。

软件系统的并发控制一般是通过加锁（有乐观锁和悲观锁两种）来实现，乐观锁是一种事后补救措施，是通过程序的逻辑控制版本来实现的，而悲观锁是事前的一种预防措施，它利用数据库的锁机制来实现。

虽然乐观锁能够提高系统的性能，但它是对发生冲突的访问进行事后的补救，应用在用户输入数据量很少的场合比较适合，但如果在企业ERP，用户与系统交互涉及大量数据在页面表单上录入，如果事后提交失败后才提示用户要重新录入是很不现实的，所以有必要进行事前控制，这就要采用悲观锁。

在多个客户端可能读取同一笔数据或同时更新一笔数据的情况下，防止同一个数据被修改而造成混乱，最简单的手段就是在读取时对数据进行锁定，其它客户端不能对同一笔数据进行更新的读取动作。

一个典型的倚赖数据库的悲观锁调用：
select * from account where name=”John” for update

这条 sql 语句锁定了 account 表中所有符合检索条件（name=”Erica”）的记录。本次事务提交之前（事务提交时会释放事务过程中的锁），外界无法修改这些记录。Hibernate 的悲观锁，也是基于数据库的锁机制实现。
下面的代码实现了对查询记录的加锁：
String hqlStr ="from TUser as user where user.name='John'";
Query query = session.createQuery(hqlStr);
query.setLockMode("user",LockMode.UPGRADE); // 加锁
List userList = query.list();// 执行查询，获取数据
query.setLockMode 对查询语句中，特定别名所对应的记录进行加锁（我们为TUser 类指定了一个别名 “user” ），这里也就是对返回的所有 user 记录进行加锁。
观察运行期 Hibernate 生成的 SQL 语句：
select tuser0_.id as id, tuser0_.name as name, tuser0_.group_id
as group_id, tuser0_.user_type as user_type, tuser0_.sex as sex
from t_user tuser0_ where (tuser0_.name='John' ) for update
这里 Hibernate 通过使用数据库的 for update 子句实现了悲观锁机制。
Hibernate 的加锁模式有：
LockMode.NONE ： 无锁机制。
LockMode.WRITE ： Hibernate 在 Insert 和 Update 记录的时候会自动获取。
LockMode.READ ： Hibernate 在读取记录的时候会自动获取。
以上这三种锁机制一般由 Hibernate 内部使用，如 Hibernate 为了保证 Update过程中对象不会被外界修改，会在 save 方法实现中自动为目标对象加上 WRITE 锁。
LockMode.UPGRADE ：利用数据库的 for update 子句加锁。
LockMode. UPGRADE_NOWAIT ： Oracle 的特定实现，利用 Oracle 的 for update nowait 子句实现加锁。
上面这两种锁机制是我们在应用层较为常用的，加锁一般通过以下方法实现：
Criteria.setLockMode
Query.setLockMode
Session.lock
注意，只有在查询开始之前（也就是 Hiberate 生成 SQL 之前）设定加锁，才会真正通过数据库的锁机制进行加锁处理，否则，数据已经通过不包含 for update 子句的 Select SQL 加载进来，所谓数据库加锁也就无从谈起。

       持久状态: 持久化对象的实例在数据库中有对应的记录，并拥有一个持久化表示（ID）。对持久化对象进行delete操作后，数据库中对应的记录将被删除，那么持久化对象与数据库记录不再存在对应关系，持久化对象变成临时状态。 
        持久化对象被修改变更后，不会马上同步到数据库，直到数据库事务提交。在同步之前，持久化对象是脏的（Dirty）。
            例如： 
              Emp e=new Emp(); //创建了临时的对象 
               EmpDAO edao= new empDAO(); 
               e=edao.findbyEmpno((long) 7786);    //使对象与数据库记录对应，从而持久化 
               e.setEname("新的名字");                     //修改了持久化对象，使之处于 Dirty 
               ...... 
               edao.saveorupdate(e);                      //保存，但是仍然 Dirty 
               tran.commit();                             //提交，实现与数据库同步，不再Dirty 
               ......

       游离状态：当Session进行了Close、Clear或者evict后，持久化对象虽然拥有持久化标识符和与数据库对应记录一致的值，但是因为会话已经消失，对象不在持久化管理之内，所以处于游离状态（也叫：脱管状态）。游离状态的对象与临时状态对象是十分相似的，只是它还含有持久化标识。

          其中，持久化状态的对象，简称为：PO 
          而临时状态和游离状态的对象，简称为：VO

          1、通过get()或load()方法得到的实例都是持久化状态的。 
          2、当把session关闭时，session缓存中的持久化对象也变成游离态

             因关闭session而变成游离态的可以通过lock、save、update变成持久态 
          3、持久态实例可以通过调用delete()变成游离态 
             而游离状态的实例可以通过调用lock()或者replicate()进行持久化 
          4、save()和persist()将会引发SQL的insert，delete()会引发SQL的delete 
             update()或merge()会引发SQL的update，对持久化实例的修改在刷新提交的时候会

             被检测到, 它会引发SQL的update 
              saveOrUpdate()或者replicate ()会引发SQL的insert或者update

/*
  * (non-Javadoc)
  *
  * @see com.cns.certservice.dao.CertBindTabDao#updateCertBind(com.cns.certservice.vo.CertBindView)
  */
 public boolean updateCertBind(CertBindView view) throws DAOException {
  boolean res = false;
  if (view.getId()==0) {
   throw new DAOException("getId from CertBindView is null!");
  }
  Session session= null;
  try {
   session = HibernateTemplate.getInstance().getSession();
   Certbind c = (Certbind) session.get(Certbind.class, view.getId());
   if (!CheckEmpty.isEmpty(view.getAgentcode()))
    c.setAgentcode(view.getAgentcode());
   if (!CheckEmpty.isEmpty(view.getExtend1()))
    c.setExtend1(view.getExtend1());
   if (!CheckEmpty.isEmpty(view.getExtend2()))
    c.setExtend2(view.getExtend2());
   if (!CheckEmpty.isEmpty(view.getIpasskeyno()))
    c.setIpasskeyno(view.getIpasskeyno());
   if (!CheckEmpty.isEmpty(view.getUsercode()))
    c.setUsercode(view.getUsercode());
   if (view.getAgenttype() != 0)
    c.setAgenttype(view.getAgenttype());
   res = HibernateTemplate.getInstance().updateObject(c);
  } catch (HibernateException e) {
   log.error(e,e);
   throw new DAOException(e);
  }finally{
   if (session != null && session.isConnected())
    session.close();
  }
  return res;
 }

 private Certbind getCertBind(CertBindView view) {
  Certbind c = new Certbind();
  if (view.getAddtime() != null)
   c.setAddtime(view.getAddtime());
  if (!CheckEmpty.isEmpty(view.getAgentcode()))
   c.setAgentcode(view.getAgentcode());
  if (!CheckEmpty.isEmpty(view.getExtend1()))
   c.setExtend1(view.getExtend1());
  if (!CheckEmpty.isEmpty(view.getExtend2()))
   c.setExtend2(view.getExtend2());
  if (!CheckEmpty.isEmpty(view.getIpasskeyno()))
   c.setIpasskeyno(view.getIpasskeyno());
  if (!CheckEmpty.isEmpty(view.getUsercode()))
   c.setUsercode(view.getUsercode());
  if(view.getId()!=0)c.setId(view.getId());
  if (view.getAgenttype() != 0)
   c.setAgenttype(view.getAgenttype());
  return c;
 }

 private CertBindView getCertBindView(Certbind view) {
  CertBindView c = new CertBindView();
  if (view.getAddtime() != null)
   c.setAddtime(view.getAddtime());
  if (!CheckEmpty.isEmpty(view.getAgentcode()))
   c.setAgentcode(view.getAgentcode());
  if (!CheckEmpty.isEmpty(view.getExtend1()))
   c.setExtend1(view.getExtend1());
  if (!CheckEmpty.isEmpty(view.getExtend2()))
   c.setExtend2(view.getExtend2());
  if (!CheckEmpty.isEmpty(view.getIpasskeyno()))
   c.setIpasskeyno(view.getIpasskeyno());
  if (!CheckEmpty.isEmpty(view.getUsercode()))
   c.setUsercode(view.getUsercode());
  if(view.getId()!=0)c.setId(view.getId());
  if (view.getAgenttype() != 0)
   c.setAgenttype(view.getAgenttype());
  return c;
 }

import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.cns.certservice.exception.DAOException;

public class HibernateTemplate {

    private HibernateTemplate() {

    }

    /**
     * static final session factory
     */
    private static SessionFactory sessionFactory = null;

    /**
     * local thread variable used for storing share session instance
     */
    private static final ThreadLocal localSession = new ThreadLocal();

    /**
     * log4j logger
     */
    private static final Logger logger = Logger
            .getLogger(HibernateTemplate.class);
    /**
     * use JTA transaction
     */
    /**
     * 该工具唯一实例。
     */
    private static HibernateTemplate instance = null;
    private static Transaction tx = null;
    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
    private static final Configuration cfg = new Configuration();
    /** Holds a single instance of Session */
    private static final ThreadLocal threadLocal = new ThreadLocal();

    /**
     * 获取持久工具的唯一实例，以后不是使用单实例模式，而不是采用对象池支持。
     * @return　PersistentTool
     * @throws BaseException
     */
    public synchronized static HibernateTemplate getInstance() {
        if (instance == null) {
            instance = new HibernateTemplate();
            instance.initHibernate();
        }
        return instance;
    }

    /**
     * 实现Hibernate的初始化配置环境。
     */
    public void initHibernate() {
        try {
            //此处从系统路径中获取配置文件
            cfg.configure(CONFIG_FILE_LOCATION);
        } catch (HibernateException ex) {
            ex.printStackTrace();
        }
        try {
            // 装载配置，构造SessionFactory对象
            sessionFactory = cfg.buildSessionFactory();
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }

    /**
     * Get the share session
     * @
     * @return Session share session
     */
    public  Session getSession() {
        logger.debug("Now enter into getSession method of DaoUtil");
        //obtain share session
        Session session = (Session) localSession.get();
        try {
            if (session == null||!session.isOpen()) {
                //get session by session factory
                session = sessionFactory.openSession();
                localSession.set(session);
            }
        } catch (HibernateException ex) {
            ex.printStackTrace();

        }
        return session;
    }

    /**
     * Close share session
     * @
     */
    public  void close() {
        logger.debug("Now enter into closeSessionl");
        //obtain share session
        Session session = (Session) localSession.get();
        localSession.set(null);
        if (session != null) {
            try {
                session.flush();
                session.close();
            } catch (HibernateException ex) {
                ex.printStackTrace();

            }
        }
    }

    /**
     * Begin JTA transaction
     * @
     */
    public  void beginTransaction() {
        logger.debug("Now enter into beginTransaction");
        try {
            Session session = (Session) localSession.get();
            tx = session.beginTransaction();
        } catch (Exception ex) {
            ex.printStackTrace();

        }
    }

    /**
     * Commit transaction
     * @
     */
    public  void commitTransaction() {
        try {
            tx.commit();
        } catch (Exception ex) {
            ex.printStackTrace();

        }
    }

    /**
     * Rollback transaction when breaching ACID operation
     * @
     */
    public  void rollbackTransaction() {
        try {
            tx.rollback();
        } catch (Exception ex) {
            ex.printStackTrace();

        }
    }

    /**
     * Insert a record into table
     * @param obj Object
     * @throws DAOException
     * @
     */
    public  int insertObject(Object obj) throws DAOException {
     int res = 0;
        logger.debug("Now enter into insertObject");
        //obtain current share session
        try {
            Session session = HibernateTemplate.getInstance().getSession();
            beginTransaction();
            Object robj = session.save(obj);
            if (robj instanceof Integer) {
    res = (Integer) robj;
   }
            if (robj instanceof String) {
    res =1;
   }
            session.flush();
        } catch (HibernateException ex) {
            rollbackTransaction();
            logger.error("insertObject error:", ex);
            throw new DAOException(ex);
        } finally {
            commitTransaction();
            close();
        }
        return res;
    }

    /**
     * Delete a record of database table by Hibernate po object
     * @param obj Object
     * @throws DAOException
     * @
     */
    public  boolean deleteObject(Object obj) throws DAOException {
     boolean res = false;
        logger.debug("Now enter into deleteObject method");
        //obtain current share session
        try {
            Session session = HibernateTemplate.getInstance().getSession();
            beginTransaction();
            session.delete(obj);
            session.flush();
            res = true;
        } catch (HibernateException ex) {
            rollbackTransaction();
            logger.error("deleteObject error:", ex);
            throw new DAOException(ex);
        } finally {
            commitTransaction();
            close();
        }
        return res;
    }

    /**
     * Update a record of database table
     * @param ob Object
     * @throws DAOException
     * @
     */
    public  boolean updateObject(Object ob) throws DAOException {
     boolean res = false;
        logger.debug("Now enter into updateObject");
        //obtain current share session
        try {
            Session session = HibernateTemplate.getInstance().getSession();
            beginTransaction();
            session.update(ob);
            session.flush();
            res= true;
        } catch (HibernateException ex) {
         rollbackTransaction();
          logger.error("updateObject error:", ex);
          throw new DAOException(ex);
        } finally {
            commitTransaction();
            close();
        }
        return res;
    }
}