注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

天涯倦客的博客

祝福你朋友永远快乐!

 
 
 

日志

 
 

转:.NET 数据库连接池类  

2013-09-17 15:20:06|  分类: Oracle |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
  1. /// <summary>  
  2. /// 数据库连接池  
  3.  /// </summary>  
  4. internal static class WAFConnectionPool  
  5. {  
  6.    //list of the pool objects  
  7.    private static System.Collections.Generic.HashSet<PooledOracleConnection> pooled;  
  8.   
  9.    //clean-up interval  
  10.    private static readonly long GARBAGE_INTERVAL = 30 * 1000; //默认回收  
  11.     private static readonly long FORCE_GARBAGE_INTERVAL = 20 * 60 * 1000; //强制回收,时隔2分钟  
  12.     private static readonly long LIFECYCLE_GARBAGE_INTERVAL = 10 * 60 * 1000; //生存周期,时隔10分钟   
  13.   
  14.     private static readonly string CONNECTION_STRING = Applications.WAFConnectionString;  
  15.   
  16.     /// <summary>  
  17.     /// 数据库连接池  
  18.     /// </summary>  
  19.     static WAFConnectionPool()  
  20.     {  
  21.         pooled = new HashSet<PooledOracleConnection>();  
  22.         //自动回收timer  
  23.         System.Timers.Timer timer = new System.Timers.Timer();  
  24.         timer.Enabled = true;  
  25.         timer.Interval = GARBAGE_INTERVAL;  
  26.         timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);  
  27.     }  
  28.   
  29.     /// <summary>  
  30.     /// 仅用户debug;查看连接池连接对象  
  31.     /// </summary>  
  32.     /// <returns></returns>  
  33.     public static string Debug()  
  34.     {  
  35.         lock (pooled)  
  36.         {  
  37.             StringBuilder sb = new StringBuilder("--------------"+pooled.Count+"------------");  
  38.             sb.AppendLine();  
  39.             int i = 0;  
  40.             foreach (PooledOracleConnection conn in pooled)  
  41.             {  
  42.                 sb.AppendLine((i++) +"-oracle hashcode:" + conn.GetConnectionHashCode);  
  43.                 sb.Append("-using:" + conn.Using);  
  44.                 sb.Append("-state:" + conn.ConnectionState);  
  45.             }  
  46.             return sb.ToString();  
  47.         }  
  48.     }  
  49.   
  50.     /// <summary>  
  51.     /// 从连接池获取一个连接对象  
  52.      /// </summary>  
  53.     /// <returns>Oracle连接对象</returns>  
  54.     public static OracleConnection BorrowOpenningConnection()  
  55.     {  
  56.         //OracleConnection conn = new OracleConnection(CONNECTION_STRING);  
  57.         //conn.Open();  
  58.         //return conn;  
  59.         lock (pooled)  
  60.         {  
  61.             int count = pooled.Count;  
  62.             for (int i = (count - 1); i >= 0; i--)  //集合和数组的下标都是从零开始的  
  63.             {  
  64.                 PooledOracleConnection instance = pooled.ElementAt(i);  
  65.                 //如果连接池存在空闲对象  
  66.                 if (!instance.Using)  
  67.                 {  
  68.                     instance.Using = true;  
  69.                     instance.LastCheckOut = DateTime.Now;  
  70.                     if (instance.Connection.State != System.Data.ConnectionState.Open) instance.Connection.Open();  
  71.                     return instance.Connection;  
  72.                 }  
  73.             }  
  74.             //增加一个连接到连接池  
  75.               PooledOracleConnection n = new PooledOracleConnection(new OracleConnection(CONNECTION_STRING), true);  
  76.             pooled.Add(n);  
  77.             n.Connection.Open();  
  78.             return n.Connection;  
  79.         }  
  80.     }  
  81.   
  82.     /// <summary>  
  83.     /// 把借出的连接放回到连接池.  
  84.     /// </summary>  
  85.     /// <param name="conn">oracle连接对象</param>  
  86.     public static void ReturnConnection(OracleConnection conn)  
  87.     {  
  88.         //conn.Close();  
  89.         //OracleConnection.ClearPool(conn);  
  90.         //return;  
  91.         lock (pooled)  
  92.         {  
  93.             foreach (PooledOracleConnection instance in pooled)  
  94.             {  
  95.                 if (conn.GetHashCode() == instance.GetConnectionHashCode)  
  96.                 {  
  97.                     instance.Using = false;  
  98.                     instance.LastCheckOut = DateTime.Now;  
  99.                     return;  
  100.                 }  
  101.             }  
  102.         }  
  103.     }  
  104.   
  105.     /// <summary>  
  106.     /// 自动回收事件  
  107.     /// </summary>  
  108.     /// <param name="sender">Timer对象</param>  
  109.     /// <param name="e">ElapsedEventArgs实例</param>  
  110.     private static void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)  
  111.     {  
  112.         DateTime now = DateTime.Now;  
  113.         lock (pooled)  
  114.         {  
  115.             int count = pooled.Count;  
  116.             for (int i = (count - 1); i >= 0; i--)  
  117.             {  
  118.               PooledOracleConnection instance = pooled.ElementAt(i);  
  119.               //不在使用中,同時到了它的生命期  
  120.                 //在使用中,最後一次签出时间到現在大于强制回收时间  
  121.                 //不在使用中,不使用的停留时间大于回收时间  
  122.                 if ((!instance.Using && now > instance.Created.AddMilliseconds(LIFECYCLE_GARBAGE_INTERVAL)) || now >       instance.LastCheckOut.AddMilliseconds(instance.Using ? FORCE_GARBAGE_INTERVAL : GARBAGE_INTERVAL))  
  123.                 {  
  124.                     pooled.Remove(instance);  
  125.                     if (instance.Connection.State == System.Data.ConnectionState.Open) instance.Connection.Close();  
  126.                     instance.Connection.Dispose();  
  127.                     OracleConnection.ClearPool(instance.Connection);  
  128.                     instance = null;  
  129.                 }  
  130.             }  
  131.         }  
  132.     }  
  133.     /// <summary>  
  134.     /// Oracle连接池对象  
  135.     /// </summary>  
  136.     class PooledOracleConnection  
  137.     {  
  138.         DateTime _created = DateTime.Now;  
  139.         /// <summary>  
  140.         /// 创建时间  
  141.         /// </summary>  
  142.         public DateTime Created { get { return _created; } }  
  143.   
  144.         DateTime _lastCheckOut = DateTime.Now;  
  145.         /// <summary>  
  146.         /// 最后 借出 时间  
  147.         /// </summary>  
  148.         public DateTime LastCheckOut  
  149.         {  
  150.             get { return _lastCheckOut; }  
  151.             set { _lastCheckOut = value; }  
  152.         }  
  153.   
  154.         OracleConnection _connection;  
  155.         /// <summary>  
  156.         /// oracle 连接对象  
  157.         /// </summary>  
  158.         public OracleConnection Connection  
  159.         {  
  160.             get  
  161.             {  
  162.                 return _connection;  
  163.             }  
  164.         }  
  165.   
  166.         /// <summary>  
  167.         /// 连接状态  
  168.         /// </summary>  
  169.         public System.Data.ConnectionState ConnectionState  
  170.         {  
  171.             get { return _connection.State; }  
  172.         }  
  173.         int _connectionHashCode;  
  174.         /// <summary>  
  175.         /// 连接对象的hashcode,用于返回借出对象的時候使用  
  176.           /// </summary>  
  177.         public int GetConnectionHashCode  
  178.         {  
  179.             get { return _connectionHashCode; }  
  180.         }  
  181.   
  182.         bool _useng = false;  
  183.         /// <summary>  
  184.         /// 是否在使用中  
  185.           /// </summary>  
  186.         public bool Using { get { return _useng; } set { _useng = value; } }  
  187.   
  188.         /// <summary>  
  189.         /// 构造函数  
  190.           /// </summary>  
  191.         /// <param name="connection">Oracle连接对象</param>  
  192.         /// <param name="useng">是否在使用中</param>  
  193.         public PooledOracleConnection(OracleConnection connection, bool useng)  
  194.         {  
  195.             this._connection = connection;   
  196.             this._useng = useng;  
  197.             this._connectionHashCode = connection.GetHashCode();  
  198.         }  
  199.     }  
  200. }  
转自:http://blog.csdn.net/byondocean/article/details/6861363
  评论这张
 
阅读(374)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017