nhibernet并发出错

今天进行压力测试时当用户数量到100人就报很多莫名奇妙的错误，查一下日志，基本上都是与nhibernet有关，错误代码如下:

using System;
using System.Data;
using System.Collections;

using System.Collections.Generic;
using System.Text;
using System.Web;

using NHibernate;
using NHibernate.Cfg;
using NHibernate.Engine;            //ISessionFactoryImplementor
using Iesi.Collections;
using log4net;

namespace Com.DRPENG.Common.DBUtility
{
    /// <summary>
    /// 
    /// </summary>
    public partial class NHibernateHelper
    {
        private static ILog log = LogManager.GetLogger(typeof(NHibernateHelper));
        private static NHibernate.Cfg.Configuration cfg = null;
        private static ISessionFactory factory = null;
        //private static ISessionFactoryImplementor Ifactory = null;
        private static ISession session = null;
        private static object obj = new object();
        private static string SQLCON = Com.DRPENG.Common.WebStruct.Config.AppConfig.DataAccessConfig.ConnectionString;

        /// <summary>
        /// ISession KEY      
        /// </summary>
        public static string ISESSION_KEY = "NHibernateHelper.ISession";

        #region 初始化NHibernate
        /// <summary>
        /// 初始化NHibernate (从配置文件中读取配置信息)
        /// </summary>
        /// <returns>会话工厂</returns>
        public static ISessionFactory BuildFactory()
        {
            lock (obj)
            {
                try
                {
                    if (cfg == null || factory == null)
                    {
                        string configPath = System.Web.HttpContext.Current.Request.PhysicalApplicationPath + "hibernate.cfg.xml";
                        // Configure()方法是为了在hibernate.cfg.xml中查找属性
                        cfg = new Configuration().Configure(configPath);
                        Hashtable ht = new Hashtable();
                        // 对应于Ado.Net的连接串
                        ht.Add("hibernate.connection.connection_string", SQLCON);
                        cfg.AddProperties(ht);
                        return factory = cfg.BuildSessionFactory();
                    }
                    return factory;
                }
                catch (Exception ex)
                {
                    log.Info(string.Format("初始化ISessionFactory失败！失败原因：{0}", ex.ToString()));
                    throw ex;
                }
            }
        }
        #endregion

        #region 获取会话
        /// <summary>
        /// 获取会话
        /// </summary>
        /// <returns>会话ISession</returns>
        public static ISession GetSession()
        {
            try
            {
                if (HttpContext.Current != null && HttpContext.Current.Items.Contains(ISESSION_KEY))
                {
                    session = (ISession)HttpContext.Current.Items[ISESSION_KEY];
                    if (session.Connection.State == ConnectionState.Closed)
                        session.Connection.Open();
                }
                else
                {
                    if (factory == null)
                        factory = BuildFactory();
                    session = factory.OpenSession();
                    HttpContext.Current.Items[ISESSION_KEY] = session;
                }
                return session;
            }
            catch (HibernateException ex)
            {
                log.Info(string.Format("获取会话失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+1 关闭会话
        /// <summary>
        /// 重载+1 关闭会话
        /// <param name="session">会话</param>
        /// </summary>
        public static void CloseSession()
        {
            try
            {
                CloseSession(session);
            }
            catch (Exception ex)
            {
                log.Info(string.Format("关闭会话失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+2 关闭会话
        /// <summary>
        /// 重载+2 关闭会话
        /// <param name="session">会话</param>
        /// </summary>
        public static void CloseSession(ISession session)
        {
            try
            {
                if (session != null && session.IsOpen)
                {
                    //session.Clear();
                    if(session.Transaction!=null&&!session.Transaction.WasCommitted)
                        session.Transaction.Rollback();
                    session.Flush();
                    session.Close();
                }
                if (HttpContext.Current != null && HttpContext.Current.Items.Contains(ISESSION_KEY))
                {
                    HttpContext.Current.Items.Remove(ISESSION_KEY);
                }
            }
            catch (Exception ex)
            {
                log.Info(string.Format("关闭会话失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+1 获取对象
        /// <summary>
        /// 重载+1 获取对象
        /// </summary>
        /// <param name="type"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public static Object Get(Type type, object id)
        {
            try
            {
                return session.Get(type, id);
            }
            catch (HibernateException ex)
            {
                log.Info(string.Format("获取对象失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+2 获取对象
        /// <summary>
        /// 重载+2 获取对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="type"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public static Object Get(ISession session, Type type, object id)
        {
            try
            {
                return session.Get(type, id);
            }
            catch (HibernateException ex)
            {
                log.Info(string.Format("获取对象失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+1 保存对象
        /// <summary>
        /// 重载+1 保存对象
        /// </summary>
        /// <param name="obj">对象</param>
        public static void Save(Object obj)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Save(obj);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("保存失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+2 保存对象
        /// <summary>
        /// 重载+2 保存对象
        /// </summary>
        /// <param name="obj">对象</param>
        /// <param name="id">ID</param>
        public static void Save(Object obj, object id)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Save(obj, id);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("保存失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+3 保存对象
        /// <summary>
        /// 重载+3 保存对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="obj">对象</param>
        public static void Save(ISession session, Object obj)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Save(obj);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("保存失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+4 保存对象
        /// <summary>
        /// 重载+4 保存对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="obj">对象</param>
        /// <param name="id">ID</param>
        public static void Save(ISession session, Object obj, object id)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Save(obj, id);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("保存失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+1 更新对象
        /// <summary>
        /// 重载+1 更新对象
        /// </summary>
        /// <param name="obj">对象</param>
        public static void Update(Object obj)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Update(obj);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("更新失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+2 更新对象
        /// <summary>
        /// 重载+2 更新对象
        /// </summary>
        /// <param name="obj">对象</param>
        /// <param name="id">ID</param>
        public static void Update(Object obj, object id)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Update(obj, id);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("更新失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+3 更新对象
        /// <summary>
        /// 重载+3 更新对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="obj">对象</param>
        public static void Update(ISession session, Object obj)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Update(obj);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("更新失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+4 更新对象
        /// <summary>
        /// 重载+4 更新对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="obj">对象</param>
        /// <param name="id">ID</param>
        public static void Update(ISession session, Object obj, object id)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Update(obj, id);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("更新失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+1 保存or更新对象
        /// <summary>
        /// 重载+1 保存or更新对象
        /// </summary>
        /// <param name="obj"></param>
        public static void SaveOrUpdate(object obj)
        {
            try
            {
                session.SaveOrUpdate(obj);
            }
            catch (Exception ex)
            {
                log.Info(string.Format("保存or更新失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+2 保存or更新对象
        /// <summary>
        /// 重载+2 保存or更新对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="obj"></param>
        public static void SaveOrUpdate(ISession session, object obj)
        {
            try
            {
                session.SaveOrUpdate(obj);
            }
            catch (Exception ex)
            {
                log.Info(string.Format("保存or更新失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+1 删除对象
        /// <summary>
        /// 重载+1 删除对象
        /// </summary>
        /// <param name="obj">对象</param>
        public static void Delete(Object obj)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Delete(obj);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("删除失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+2 删除对象
        /// <summary>
        /// 重载+2 删除对象
        /// </summary>
        /// <param name="query">查询</param>
        /// <returns>受影响记录的行数</returns>
        public static int Delete(string query)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                int getValue = session.Delete(query);
                TransCommit(tx);
                return getValue;
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("删除失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+3 删除对象
        /// <summary>
        /// 重载+3 删除对象
        /// </summary>
        /// <param name="query">查询</param>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <returns>受影响记录的行数</returns>
        public static int Delete(string query, object value, NHibernate.Type.IType type)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                int getValue = session.Delete(query, value, type);
                TransCommit(tx);
                return getValue;
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("删除失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+4 删除对象
        /// <summary>
        /// 重载+4 删除对象
        /// </summary>
        /// <param name="query">查询</param>
        /// <param name="values"></param>
        /// <param name="types"></param>
        /// <returns>受影响记录的行数</returns>
        public static int Delete(string query, object[] values, NHibernate.Type.IType[] types)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                int getValue = session.Delete(query, values, types);
                TransCommit(tx);
                return getValue;
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("删除失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+5 删除对象
        /// <summary>
        /// 重载+5 删除对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="obj">对象</param>
        public static void Delete(ISession session, Object obj)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                session.Delete(obj);
                TransCommit(tx);
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("删除失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+6 删除对象
        /// <summary>
        /// 重载+6 删除对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="query">查询</param>
        /// <returns>受影响记录的行数</returns>
        public static int Delete(ISession session, string query)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                int getValue = session.Delete(query);
                TransCommit(tx);
                return getValue;
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("删除失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+7 删除对象
        /// <summary>
        /// 重载+7 删除对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="query">查询</param>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <returns>受影响记录的行数</returns>
        public static int Delete(ISession session, string query, object value, NHibernate.Type.IType type)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                int getValue = session.Delete(query, value, type);
                TransCommit(tx);
                return getValue;
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("删除失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+8 删除对象
        /// <summary>
        /// 重载+8 删除对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="query">查询</param>
        /// <param name="values"></param>
        /// <param name="types"></param>
        /// <returns>受影响记录的行数</returns>
        public static int Delete(ISession session, string query, object[] values, NHibernate.Type.IType[] types)
        {
            ITransaction tx = session.BeginTransaction();
            try
            {
                int getValue = session.Delete(query, values, types);
                TransCommit(tx);
                return getValue;
            }
            catch (HibernateException ex)
            {
                TransRollback(tx);
                log.Info(string.Format("删除失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+1 创建查询对象
        /// <summary>
        /// 重载+1 创建查询对象
        /// </summary>
        /// <param name="hqlStr">HQL语句</param>
        /// <param name="param">参数列表</param>
        /// <returns>IQuery对象</returns>
        public static IQuery CreateQuery(String hqlStr, IDictionary param)
        {
            try
            {
                IQuery query = session.CreateQuery(hqlStr);
                string[] NamedParams = query.NamedParameters;
                if (NamedParams != null && NamedParams.Length > 0)
                {
                    for (int i = 0; i < NamedParams.Length; i++)
                    {
                        string name = NamedParams[i];
                        query.SetParameter(name, param[name]);
                    }
                }
                return query;
            }
            catch (Exception ex)
            {
                log.Info(string.Format("创建查询对象失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 重载+2 创建查询对象
        /// <summary>
        /// 重载+2 创建查询对象
        /// </summary>
        /// <param name="session">会话</param>
        /// <param name="hqlStr">HQL语句</param>
        /// <param name="param">参数列表</param>
        /// <returns>IQuery对象</returns>
        public static IQuery CreateQuery(ISession session, String hqlStr, IDictionary param)
        {
            try
            {
                IQuery query = session.CreateQuery(hqlStr);
                string[] NamedParams = query.NamedParameters;
                if (NamedParams != null && NamedParams.Length > 0)
                {
                    for (int i = 0; i < NamedParams.Length; i++)
                    {
                        string name = NamedParams[i];
                        query.SetParameter(name, param[name]);
                    }
                }
                return query;
            }
            catch (Exception ex)
            {
                log.Info(string.Format("创建查询对象失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 提交事务
        /// <summary>
        /// 提交事务
        /// </summary>
        /// <param name="tx"></param>
        public static void TransCommit(ITransaction tx)
        {
            try
            {
                if (!tx.WasRolledBack)
                    tx.Commit();
            }
            catch (HibernateException ex)
            {
                tx.Rollback();
                log.Info(string.Format("提交事务失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion

        #region 回滚事务
        /// <summary>
        /// 回滚事务
        /// </summary>
        /// <param name="tx"></param>
        public static void TransRollback(ITransaction tx)
        {
            try
            {
                tx.Rollback();
            }
            catch (HibernateException ex)
            {
                log.Info(string.Format("回滚事务失败！失败原因：{0}", ex.ToString()));
                throw ex;
            }
        }
        #endregion
    }
}

 后来经过李永京的帮忙，知道错在了在方法里用了事务。