connectmanager.java

好像是一个SQL执行器的设计实现

package mytools.sqlclient;

import mytools.util.*;

/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2001</p>
 * <p>Company: </p>
 * @author unascribed
 * @version 1.0
 */

public class ConnectManager extends Thread
{
public static final int MAX_CONN_NUM=Config.getIntParmValue("mytools.max_connect_num"); //最大连接数
public static final int INIT_CONN_NUM=Config.getIntParmValue("mytools.init_connect_num"); //初始ejb连接数
public static final int MAX_IDLE_TIME=Config.getIntParmValue("mytools.max_idle_time"); //最大连接空闲时间(秒)
public static final int MAX_IDLE_CONN_NUM=Config.getIntParmValue("mytools.max_idle_connect_num"); //最大空闲超时连接数
public static final int INCREASE_CONN_NUM=Config.getIntParmValue("mytools.increase_connect_num"); //每次增加的连接数

public static final int SCAN_INTERNAL=60;  //检查时间间隔(秒)

private boolean isStop=false;   //停止标志
private int curConnectNum=0;    //当前连接数
private  ConnectInfo[] conList=null;          //连接信息
private static Object lockObject = new Object();
private static ConnectManager connectMng = null;

private boolean isFirstSql = true ;//是否用第一个sql服务器端口号

     protected ConnectManager()
     {
        init();
        this.start();
     }

     /**
     功能:管理连接处理
     @param 无
     @return 无
     */
     public void run()
     {
        while(true)
        {
            Util.sleep(SCAN_INTERNAL);

            synchronized(lockObject)
            {
                if (isStop) break;

                int li_idle_num=getTimeOutIdleConnectNum();  //超时空闲连接数
                if (li_idle_num>MAX_IDLE_CONN_NUM)
                {
                    int li_remove_num=li_idle_num-MAX_IDLE_CONN_NUM;
                    removeIdleConnects(li_remove_num);
                }

                //根据需要分配连接
                if (hasAvailabelResource()==null)  //无可用连接了,需增加连接
                {
                    //分配连接
                    if (curConnectNum<MAX_CONN_NUM)
                    {
                      addConnects();   //增加一些连接
                      lockObject.notifyAll();
                    }
                }
            }
        }//end of while
     }

     /**
     功能:删除指定数目的空闲连接
     @param pi_remove_num 删除数
     @return 无
     */
     private void removeIdleConnects(int pi_remove_num)
     {
        int li_remove_num=0;
        for (int i=0;i<curConnectNum;i++)
        {
            if (isTimeOutIdleConnect(conList[i]))
            {
               removeConnect(i);
               li_remove_num++;
               if (li_remove_num>=pi_remove_num) break;
            }
        }
        curConnectNum-=li_remove_num;
     }

     /**
     功能:删除指定的连接
     @param pi_idx 连接索引
     @return 无
     */
     private void removeConnect(int pi_idx)
     {
        try
        {
          Util.logInfo("remove connect:"+conList[pi_idx].getConnection());
          conList[pi_idx].getConnection().close();
        }
        catch(Exception ex)
        {
           ex.printStackTrace();
           Util.error("removeConnect:exception:"+ex);
        }
        for (int i=pi_idx+1;i<curConnectNum;i++)
        {
           conList[i-1]=conList[i];
        }
     }

     /**
     功能:判断指定连接是否为超时空闲连接
     @param po_info 连接信息
     @return true 是 false 非
     */
     private boolean isTimeOutIdleConnect(ConnectInfo po_info)
     {
       long ll_idle_time=System.currentTimeMillis()-po_info.getBeginTime();
       if (!po_info.isUsed() && (ll_idle_time>MAX_IDLE_TIME*1000)) return true;
       return false;
     }

     /**
     功能:取得超时空闲连接数
     @param 无
     @return 超时空闲连接数
     */
     private int getTimeOutIdleConnectNum()
     {
        int li_idle_num=0;

        for (int i=0;i<curConnectNum;i++)
        {
            if (isTimeOutIdleConnect(conList[i]))
            {
              li_idle_num++;
            }
        }
        return li_idle_num;
     }

     /**
     功能:增加一些起连接数
     @param 无
     @return 无
     */
     private void addConnects()
     {
        int li_remain_num=MAX_CONN_NUM-curConnectNum;
        int li_add_num=INCREASE_CONN_NUM>li_remain_num?li_remain_num:INCREASE_CONN_NUM;
        for (int i=0;i<li_add_num;i++)
        {
            addConnect();
        }
     }

     /**
     功能:增加一个连接
     @param 无
     @return 无
     */
     private void addConnect()
     {
       IConnection lo_conn=createNewConnection();
       if (lo_conn==null)
       {
           Util.error("addConnect:建立连接失败!");
           return ;
       }
       Util.logInfo("create new connection:"+lo_conn);
       conList[curConnectNum++]=new ConnectInfo("",lo_conn,false,false);
     }

     /**
      功能:取得一个实例
      @param 无
      @return 一个实例
     */
     public static ConnectManager getInstance()
     {
           if (connectMng == null)
           {
             synchronized (lockObject)
             {
                 if (connectMng == null)
                 {
                    connectMng = new ConnectManager();
                 }
             }
           }
           return connectMng;
     }

     /**
      功能:初始化连接信息
      @param 无
      @return true 成功 false 失败
     */
     private synchronized boolean init()
     {
        conList=new ConnectInfo[MAX_CONN_NUM];

        //初始化建立INIT_CONN_NUM个连接
        for (int i=0;i<INIT_CONN_NUM;i++)
        {
           addConnect();
        }
        Util.logInfo("初始化("+curConnectNum+")个连接成功 !");
        return true;
     }

    /**
     功能: 取得当前线程名
     @param 无
     @return 当前线程名
    */
    private String getCurThreadName()
    {
        return Thread.currentThread().getName();
    }

    /**
     功能:查找当前线程的连接
     @param ps_threadName 线程名
     @return 成功 数据库连接对象 失败或找不到 null
    */
    private IConnection findConnect(String ps_threadName)
    {
        int i;
        for (i=0;i<curConnectNum;i++)
        {
            if (conList[i].getThreadName().equals(ps_threadName)&& conList[i].isUsed())
            {
                return conList[i].getConnection();
            }
        }
        return null;
    }

    /**
     功能:创建一个数据库连接
     @param 无
     @return 成功 数据库连接 失败 null
    */
    private synchronized IConnection createNewConnection()
    {
        return ConnectionFactory.createNewConnection();
    }

    /**
     功能:释放当前线程的指定的连接
     @param 无
     @return 无
    */
    public void releaseConnection()
    {
        //Util.logInfo("in releaseConnection:"+getCurThreadName());
        synchronized(lockObject)
        {
           String ls_threadName=getCurThreadName();

            for (int i=0;i<curConnectNum;i++)
            {
                //该连接不存在未提交的事务,才释放
                if ((!conList[i].isInTransaction()) && conList[i].getThreadName().equals(ls_threadName))
                {
                    //Util.logInfo("now releaseConnection:"+ls_threadName);
                    conList[i].notUse();  //不再占用
                    lockObject.notifyAll();
                    break;
                }
            }
        }
        //Util.logInfo("end of releaseConnection:"+getCurThreadName());
    }

    /**
     功能:设置当前线程的连接正在事务中
     @param 无
     @return 无
    */
    public void setInTransaction()
    {
        setTranStatus(true);
        //Util.logInfo("end of setInTransaction :"+ls_threadName);
    }

    /**
    功能:设置连接未在事务状态中
    @param 无
    @return 无
    */
    public void setNotInTransaction()
    {
       setTranStatus(false);
    }

    /**
    功能:设置连接的事务状态
    @param ps_status 状态
    @return 无
    */
    private void setTranStatus(boolean pb_status)
    {
      String ls_threadName=getCurThreadName();

      //Util.logInfo("setInTransaction :"+ls_threadName);
      synchronized(lockObject)
      {
          for (int i=0;i<curConnectNum;i++)
          {
              if (conList[i].getThreadName().equals(ls_threadName))
              {
                  conList[i].setInTransaction(pb_status); //设置在事务中标志
                  return ;
              }
          }
      }
    }

    /**
     功能: 查找一个数据库连接
     @param 无
     @return 成功 数据库连接 失败 null
    */
    public IConnection getConnection()
    {
        String ls_threadName;

        while (true)
        {
       	    synchronized (lockObject)
            {
                ls_threadName=getCurThreadName();  //当前线程名
                //找一个现有的连接
                IConnection lo_conn=findConnect(ls_threadName);
                if (lo_conn!=null) return lo_conn;

                //找一个可用连接
                ConnectInfo lo_info=hasAvailabelResource();
                if (lo_info!=null)
                {
                   lo_info.useBy(ls_threadName);   //占用本连接
                   return lo_info.getConnection();
                }
                Util.logInfo("wait connect ! threadName:"+ls_threadName);
                //找不到,只好等了
                try
                {
                    lockObject.wait();
                }catch(Exception ex)
                {
                    ex.printStackTrace();
                }
          }
        }
    }

    /**
     功能:判断是否有可用的连接
     @param 无
     @return 有 连接对象 无 null
    */
    private ConnectInfo hasAvailabelResource()
    {
        for (int i=0;i<curConnectNum;i++)
        {
            if (!conList[i].isUsed()) return conList[i];
        }
        return null;
    }

    /**
     功能:取得当前连接数
     @param 无
     @return 当前连接数
    */
    public int getConnectionCount()
    {
        return this.curConnectNum;
    }

    /**
     功能:关闭所有连接
     @param 无
     @return 无
    */
    public void closeAllConnection()
    {
        if (conList==null) return ;
        for (int i=0;i<curConnectNum;i++)
        {
            IConnection lo_conn=conList[i].getConnection();
            if (lo_conn!=null)
            {
                try
                {
                    lo_conn.close();
                    lo_conn=null;
                }catch(Exception ex){}
                conList[i].reset();
            }
        }
    }

    /**
     功能: 显示连接信息
     @param 无
     @return 无
    */
    public void displayConnectInfo()
    {
        if (conList==null)
        {
            Util.logInfo("displayConnectInfo:no connections");
            return ;
        }
        for (int i=0;i<curConnectNum;i++)
        {
            System.out.println(conList[i]);
        }
    }

    /**
    功能:停止调度,关闭所有连接
    @param 无
    @return 无
    */
    public void shutdown()
    {
      synchronized(lockObject)
      {
          isStop=true;
      }
      closeAllConnection();
    }
}