线程安全的单例模式的几种实现

线程安全的单例模式的几种实现

---

• 单例模式是一种常见的设计模式；java Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数；有利于java垃圾回收(garbage collection)。

• 单例模式也是一种比较常见的设计模式，它到底能带给我们什么好处呢？其实无非就是三个方面的作用：

  1.控制资源的使用，通过线程同步来控制资源的并发访问；
  2.控制实例产生的数量，达到节约资源的目的。
  3.作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。

• 单例模式分为三种：懒汉式单例、饿汉式单例、登记式单例三种。

• 单例模式有以下特点：

  1.单例类只能有一个实例。
  2.单例类必须自己创建自己的唯一实例。
  3.单例类必须给所有其他对象提供这一实例。

1.懒汉式单例

    // 单例模式-懒汉式单例
    public class LazySingleton{
            // 私有静态对象，加载时候不做初始化
            private static LazySingleton m_intance=null;
            // 私有构造方法，避免外部创建实例
            private LazySingleton(){ }
            
            
            /**
             *  静态工厂方法，返回此类的唯一实例。
             *  当发现实例没有初始化的时候，才初始化。
             *  @return LazySingleton
             */
             synchronized public static LazySingleton getInstance(){
                    if(m_intance==null){
                        m_intance=new LazySingleton();
                    }
                    return m_intance;
             }
    }

2.饿汉式单例

1.在类加载的时候不创建单例实例。只有在第一次请求实例的时候创建，并且只在第一次创建后，以后不再创建该类的实例。

 /*
 *  单例模式-饿汉式单例
 */
 
 public class EagerSingleton {
         /*
         *  私有的(private)唯一(static final)实例成员，在类加载的时候就创建好了单例对象
         */
         private static final EagerSingleton m_instance = new EagerSingleton();
         /**
         *  私有构造方法，避免外部创建实例
         */
         private EagerSingleton() {
         
         }
         /**
         *  静态工厂方法，返回此类的唯一实例。
         *  @return EagerSingleton
         */
         public static EagerSingleton getInstance() {
                 return m_instance;
         }
 
 }

3.登记式单例

这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map(登记簿)中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。

/**
*  单例模式-登记式单例
*/
public class RegSingleton{
        /**
        *  登记簿，用来存放所有登记的实例
        */
        private static Map m_registry = new HashMap ();
        // 在类加载的时候添加一个实例到登记簿
        static {
              ReSingleton x=new RegSingleton ();
              m_registry.put(x.getClass().getName(),x);
        }
        /**
        * 受保护的默认构造方法
        */
        
        protected RegSingleton() {}
        
        /**
          * 静态工厂方法,返回指定登记对象的唯一实例;
          * 对于已登记的直接取出返回，对于还未登记的，先登记，           然后取出返回
          * @param name
          * @return RegSingleton
          */
          
         public static RegSingleton getInstance(String name) {
          
            if (name == null) {
                name = "RegSingleton";
            }
            if (m_registry.get(name) == null) {
            
                try{
                    m_registry.put(name, (RegSingleton)Class.forName(name).newInstance());
                }catch (InstantiationException e) {
                    e.printStackTrace();
                }catch (IllegalAccessException e){
                    e.printStackTrace();
                }catch (ClassNotFoundException e){
                    e.printStackTrace();
                }
                
                }
            return m_registry.get(name)；’  
          }
          
          /**
          *   一个示意性的商业方法
          *   @return String 
          */
          public String about() {
                return "Hello, I am RegSingleton!"；
          }

}

4.单例模式的一个应用

该应用是配置文件管理类，为了本例能正确运行，我在C盘下先建立一个xxxx.properties文件，内容如下；

user=root
password=jiafangin

这个配置文件管理类的代码如下：

/**
* 单例模式应用-单例类应用-配置文件管理
*/public class ConfigManager {
     /**
      * 属性文件全名
      */
     private static final String PFILE = "C:/xxx.properties";
     
      /**
      * 对应于属性文件的文件对象变量
      */
     private File m_file = null;

     /**
      * 属性文件的最后修改日期
      */
     private long m_lastModifiedTime = 0;
     /**

      * 属性文件所对应的属性对象变量
      */
     private Properties m_props = null;

     /**
      * 本类可能存在的唯一的一个实例
      */

     private static ConfigManager m_instance = new ConfigManager();

     /**
      * 私有构造子,用以保证外界无法直接实例化
      */

     private ConfigManager() {
         m_file = new File(PFILE);
         m_lastModifiedTime = m_file.lastModified();

         if (m_lastModifiedTime == 0) {
             System.err.println(PFILE + " file does not exist!");
         }
         m_props = new Properties();
         try {
             m_props.load(new FileInputStream(PFILE));
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     /**
      * 静态工厂方法
      *
      * @return ConfigManager
      */
     synchronized public static ConfigManager getInstance() {
         return m_instance;
     }

     /**
      * 获取属性配置项的值
      * @param name
      * @param defaultVal
      * @return Object
      */

     public final Object getConfigItem(String name, Object defaultVal) {

         long newTime = m_file.lastModified();
         if (newTime == 0) {
             //属性文件不存在
             if (m_lastModifiedTime == 0) {
                 System.err.println(PFILE + " file does not exist!");
             } else {
                 System.err.println(PFILE + " file was deleted!");
             }
             return defaultVal;
         } else if (newTime > m_lastModifiedTime) {
             m_props.clear();
             try {
                 m_props.load(new FileInputStream(PFILE));
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }

         m_lastModifiedTime = newTime;
         Object val = m_props.getProperty(name);
         if (val == null) {
             return defaultVal;
         } else {
             return val;
         }
     }
}

测试配置文件类：

/**
* 配置文件管理类测试
*/public class Test_ConfigManager {
     public static void main(String[] args) {
         ConfigManager cfgm = ConfigManager.getInstance();
         Object val1 = cfgm.getConfigItem("sdf", "leizhimin");
         Object val2 = cfgm.getConfigItem("user", "leizhimin");
         System.out.println(val1.toString());
         System.out.println(val2.toString());
     }
}

运行结果：
jiafangbin
root
Process finished with exit code 0

5.一个JDBC数据库工具类的单例实现

/**
* 单例模式在JDBC编程中的应用,用于设计数据库工具类
*/public class DBUtil {
     //单一实例
     private static final DBUtil _instance = new DBUtil();
     //数据源的JNDI
     private static final String datasource = "java:comp/env/jdbc/zvfims";

     /**
      * 私有构造方法,防止外部实例化
      */
     private DBUtil() { }

     /**
      * 数据库工具类实例工厂
      * @return DBUtil
      */
     public DBUtil getInstance() {
         return _instance;
     }

     /**
      * 业务方法:用于获取数据库连接
      * @return Connection
      */
     public Connection makeConnection() {
         Connection conn = null;
         try {
             Context ctx = new InitialContext();
             DataSource ds = (DataSource) ctx.lookup(datasource);
             conn = ds.getConnection();
         } catch (NamingException e) {
             System.out.println("获取数据源异常,请AppServer的JNDI数据源配置!");
             e.printStackTrace();
         } catch (SQLException e) {
             System.err.println("获取数据库连接发生异常!");
             e.printStackTrace();
         }
         return conn;
     }
}

通过这个单例类和开放的业务方法，可以为整个系统应用提供数据库连接。

单例模式的实现方式：懒汉式单例类和饿汉式单例类
单例模式的实现有多种方法，常见的就有懒汉式单例类和饿汉式单例类。我们前面介绍的实现方法就属于懒汉式单例类。

懒汉式单例类

对于懒汉模式，我们可以这样理解：该单例类非常懒，只有在自身需要的时候才会行动，从来不知道及早做好准备。它在需要对象的时候，才判断是否已有对象，如果没有就立即创建一个对象，然后返回，如果已经有对象就不再创建，立即返回。

懒汉模式只在外部对象第一次请求实例的时候才去创建。

饿汉式单例

对于饿汉模式，我们可以这样理解：该单例类非常饿。迫切需要吃东西，所以它在类加载的时候就立即创建对象。

我们对比一下懒汉模式和饿汉模式的优缺点：

懒汉模式，它的特点是运行时获得对象的速度比较慢，但加载类的时候比较快。它在整个应用的生命周期只有一部分时间在占用资源。
 
饿汉模式，它的特点是加载类的时候比较慢，但运行时获得对象的速度比较快。它从加载到应用结束会一直占用资源。

这 两种模式对于初始化较快，占用资源少的轻量级对象来说，没有多大的性能差异，选择懒汉式还是饿汉式都没有问题。但是对于初始化慢，占用资源多的重量级对象 来说，就会有比较明显的差别了。所以，对重量级对象应用饿汉模式，类加载时速度慢，但运行时速度快；懒汉模式则与之相反，类加载时速度快，但运行时第一次 获得对象的速度慢。
 
从用户体验的角度来说，我们应该首选饿汉模式。我们愿意等待某个程序花较长的时间初始化，却不喜欢在程序运行时等待太久，给人一种反应迟钝的感觉，所以对于有重量级对象参与的单例模式， 我们推荐使用饿汉模式 。

而对于初始化较快的轻量级对象来说，选用哪种方法都可以。如果一个应用中使用了大量单例模式，我们就应该权衡两种方法了。轻量级对象的单例采用懒汉模式，减 轻加载时的负担，缩短加载时间，提高加载效率；同时由于是轻量级对象，把这些对象的创建放在使用时进行，实际就是把创建单例对象所消耗的时间分摊到整个应 用中去了，对于整个应用的运行效率没有太大影响。

什么情况下使用单例模式
单例模式也是一种比较常见的设计模式，它到底能带给我们什么好处呢？其实无非就是三个方面的作用：
1.控制资源的使用，通过线程同步来控制资源的并发访问；
2.控制实例产生的数量，达到节约资源的目的。
3.作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两个线程或者进程之间实现通信。

比如：数据库连接池的设计一般采用单例模式，数据库连接是一种数据库资源。软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的。当然，使用数据库连接池还有很多其它的好处，可以屏蔽不同数据库之间的差异，实现系统对数据库连接的管理等等。数据库连接池属于重量级资源，一个应用中只需要保留一份即可，既节省了资源又方便管理。所以数据库连接池采用单例模式进行设计会是一个非常好的选择。
在我们日常使用的在Windows中也有不少单例模式设计的组件，象常用的文件管理器。由于Windows操作系统是一个典型的多进程多线程系统，南无在创建或者删除某个文件的时候，就不可避免的出现多个进程和线程同事操作一个文件的现象。采用单例模式设计的文件文件管理器就可以完美的解决这个问题，所有的文件操作都必须通过唯一的实例进行，这样就不会产生混乱的现象。
再比如，每台计算机可以有若干个打印机，如果每一个进程或者线程都独立的使用打印机资源的话，那么我们打印出来的结果就有可能既包含这个打印任务的一部分，有包含另外一个打印任务的一部分。所以，大多数的操作系统最终为打印任务设计了一个单利模式的假脱机服务Printer Spooler，所有的打印任务都需要通过假脱机服务进行。

实际上，配置信息类、管理类、控制类、门面类、代理类通常被设计为单例类。像java的Struts、Spring框架，都大量使用了单例模式。
使用单例模式最核心的一点是体现了面向对象封装特性中的“单一职责”和“对象自治”原则。
很多时候我们要保证类的实例只有一个。我们可能在自己的代码中判断需要的类的实例有无，无就new一个。这样看似不错。问题是，你用到这个类的地方有n个，这样你就需要n个判断。为什么不把这个职责交给类本身呢？然后让类提供一个接口访问。

所谓"懒汉式"与"饿汉式"的区别，是在与建立单例对象的时间不同。“懒汉式”是在你真正用到的时候才去建这个单例对象：
比如：有个单例对象

private static Student student = null;          //不建立对象
        Student getInstance() {
                   if(student == null) {            //先判断是否为空
                     student = new Student();   //懒汉式做法
                   }
                   
                   return student;
        }

"饿汉式"是在不管你用的用不上，一开始就建立这个单例对象： 比如：有个单例对象

private static Student student = new Student();    //建立对象

Student getInstance() {
            
            return student;         //直接返回单例对象
}

6.单利模式-----数据库连接池管理类的应用

package com.cvicse.util;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintWriter;

import java.sql.Connection;

import java.sql.Driver;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.util.Date;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Properties;

import java.util.StringTokenizer;

import java.util.Vector;

/**
* 数据库连接池管理类
* @功能：管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接池的访问。
* 客户程序可以调用getInstance()方法访问本类的唯一实例
*/
public class DBConnectionManager{
private static DBConnectionManager instance;      //唯一实例
private static int clients;     //连接的客户端
private Vector drivers = new Vector();      //驱动集合
private Hashtable pools = new Hashtable();      //连接池
private Properties dbProps;     //属性文件
private PrintWriter log;        //日志变量

/**
*   单例模式构建私有函数
*/
private DBConnectionManager(){
this.init();
}

/**
*  采用单例模式，返回唯一实例，如果是第一次调用此方法，则创建实例
*   @return DBConnectionManager 唯一实例
*/
public static synchronized DBConnectionManager getInstance(){
    if(instance == null) {
    
      instance = new DBConnectionManager();
        }
        
        clients++;
        return instance;
}
/**
*   获得一个可用的（空闲的）连接，如果没有可用连接，且已有连接数小于最大连接数限制，则创建并返回新连接
*   @param name
在属性文件中定义的连接池名字
*   @return Connection 可用连接或null
*/

public Connection getConnection(String name) {

DBConnectionPool dbPool = (DBConnectionPool)pools.get(name);
 if(dbPool != null){
 return dbPool.getConnection();
 
 }
 
 return null;      
}



/**

* 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制, 则创建并返回新连接. 否则,在指定的时间内等待其它线程释放连接.
* @param name
*            连接池名字
* @param time
*            以毫秒计的等待时间
* @return Connection 可用连接或null
*/

public Connection getConnection(String name, long time) {

DBConnectionPool dbPool = (DBConnectionPool) pools.get(name);

if (dbPool != null) {

return dbPool.getConnection(time);

}

return null;

}
/**
*   将连接对象返回给由名字指定的连接池
*   @param name 在属性文件中定义的连接池名字
*   @param con 连接对象
*/

public void freeConnection(String name,Connection con){

    DBConnectionPool dbPool=(DBConnectionPool) pools.get(name);
    if(dbPool != null){
    
    dbPool.freeConnection(con);
    }
}
/**
*   关闭所有连接，撤销驱动程序的注册   
*/
public synchronized void release(){
// 等待直到最后一个客户程序调用
if(--clients != 0){
return;
}
Enumeration allPools = pools.elements();
while (allPools.hasMoreElements()){
DBConnectionPool pool=(DBConnectionPool) allPools.nextElement();
pool.release();
}
Enumeration allDrivers = drivers.elements();
while (allDrivers.hasMoreElements()){
Driver driver = (Driver)allDrivers.nextElement();
try{
DriverManager.deregisterDriver(driver);
log("撤销JDBC驱动程序"+driver.getClass().getName()+"的注册")；
}catch(SQLException e) {
log.(e,"无法撤销下列JDBC驱动程序的注册："+driver.getClass().getName());
}
}
}
/**
*   读取属性完成初始化
*
*/
private void init(){


//      文件流输入方式
InputStream fileinputstream = null;
try{

fileinputstream = new FileInputStream("./src/db.properties");
}catch (FileNotFoundException e) {
e.printStackTrace();
}
try{

dbProps = new Properties();
dbProps.load(fileinputstream);
}catch(Exception e){
e.printStackTrace();
System.err.println("不能读取属性文件."+"请确保db.properties在classpath指定的路径中")；

return ;
}

String logFile = dbProps.getProperty("logfile","DBConnectionManager.log");
}

try{
log = new PrintWriter(new FileWriter(logFile,true),true);
}catch(IOException e){

System.err.println("无法打开日志文件："+logFile);
log = new PrintWriter(System.err);
}

// 加载驱动
loadDrivers(dbProps);
// 创建连接池
createPools(dbProps);

}
/**
*  装载和注册所有JDBC驱动程序
*  @param props 属性
*/
private void loadDrivers(Properties props) {

String driverClasses=props.getProperty("drivers");
StringTokenizer st=new StringTokenizer(driverClasses);
while (st.hasMoreElements()) {
String driverClassName = st.nextToken().trim();
try{
Driver driver = (Driver) Class.forName(driverClassName).newInstance();
DriverManager.registerDriver(driver);
drivers.addElement(driver);
log("成功注册JDBC驱动程序"+driverClassName);
}catch(Exception e){
log("无法注册JDBC驱动程序:"+driverClalssName+",错误:"+e);
}

}
}
/**
*   根据指定属性创建连接池实例。
*   @param props 连接池属性
*/

private void createPools(Properties props){
Enumeration proNames = props.propertyNames();
while(propNames.hasMoreElements()){
String name = (String) propNames.nextElement();
if(name.endsWith(".url")){
String poolName=name.substring(0,name.lastIndexOf("."));
System.out.println("poolName ||"+poolName+"|");
String url = props.getProperty(poolName+".url");
if(url == null) {
log("没有为连接池"+poolName+"指定URL");

continue;
}
String user=props.getProperty(poolName+".user");
String password=props.getProperty(poolName=".password");
String maxconn=props.getProperty(poolName+".maxconn","0");
int max;
try{
max = Integer.valueOf(maxcoon).intValue();
}catch(NumberFormatException e){
log("错误的最大连接数限制："+maxconn+".连接池："+poolName);
max=0;
}
DBConnectionPool pool = new DBConnectionPool(poolName,url,user,password,max);
pools.put(poolName,pool);
log("成功创建连接池"+poolName);
}
}

}
/**
*   将文本信息写入日志文件
*/
private void log(String msg){
log.println(new Date()+":"+msg);
}
/**
*   将文本信息与异常写入日志文件
*/
private void log(Throwable e,String msg){
log.println(new Date()+":"+msg);
e.printStackTrace(log);
}


/***************************************************************************

************************数据库连接池内部类************************************

**************************************************************************/

/**

* 

* @功能：数据库连接池内类 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最大连接数为止.

*              在返回连接给客户程序之前,它能够验证连接的有效性

*/

class DBConnectionPool{
private String poolName;         // 连接池名字
private String dbConnUrl;        //数据库的JDBC URL
private String dbUserName;     //数据库账号或null
private String dbPassWord;     //数据库账号密码或null
private int maxConn;            //此连接池允许建立的最大连接数
private int checkedOut;         //当前连接数
private Vector<Connection> freeConnections;     //保存所有可用连接

/**
*   创建新的连接池构造函数
*   @param poolName 连接池名字
*   @param dbConnUrl 数据库的JDBC URL
*   @param dbUserName 数据库账号或null
*   @param dbPassWord 数据库账号密码或null
*   @param maxConn 此连接池允许建立的最大连接数
*/
public DBConnectionPool (String poolName,String dbConnUrl,String dbUserName,String dbPassWord,int maxConn){
this.poolName = poolName;
this.dbConnUrl = dbConnUrl;
this.dbUserName = dbUserName;
this.dbPassWord = dbPassword;
this.maxConn = maxConn;
this.freeConnections = new Vector<Connection>();
}

/**

* 从连接池获得一个可用连接.如果没有空闲的连接且当前连接数小于最大连接 数限制,则创建新连接.

* 如原来登记为可用的连接不再有效,则从向量删除之,然后递归调用自己以尝试新的可用连接.

*/
public synchronized Connection getConnection(){

Connection conn = null;         //定义连接标量
if(freeConnections !=null && freeConnections.size()>0){
// 获取向量中第一个可用连接
conn = (Connection) freeConnections.firstElement();
freeConnections.removeElementAt(0);
try{
if(conn.isClosed()){
log("从连接池"+poolName+"删除一个无效连接")；
// 递归调用自己，尝试再次获取可用连接
conn = getConnection();

}catch(SQLException e ){

log("从连接池"+poolName+"删除一个无效连接");
//递归调用自己，尝试再次获取可用连接
conn=getConnection();
}
}else if(maxConn == 0 || checkedOut<maxConn) {
conn = new Connection();
}
if(conn !=null) {
chexkedOut  ++;
}
return conn;

}

/**

* 从连接池获取可用连接.可以指定客户程序能够等待的最长时间 参见前一个getConnection()方法.

* 

* @param timeout

*            以毫秒计的等待时间限制

*/
public synchronized Connection getConnection(long timeout){

long startTime = System.currentTimeMillis();
Connection conn=null;           // 定义连接标量
while ((conn = getConnection()) == null) {
try {
wait(timeout);
}catch(InterruptedException e) {
e.printStackTrace();
}
if ((System.currentTimeMillis() - startTime)>=timeout){

//wait() 返回的原因是超时
return null;
}
}

return conn;
}
/**
*   创建新的连接
*   
*   @return 返回数据库连接
*/

private Connection newConnection() {
Connection conn = null ;        //定义连接标量

try{
if (dbUserName == null) {
conn = DriverManager.getConnection(dbConnUrl);
}else{
conn = DriverManager.getConnection(dbConnUrl,dbUserName,dbPassWord);
}
log("连接池"+poolName+"创建一个新的连接")；
}catch(SQLException e){
log(e,"无法创建下列URL的连接："+dbConnUrl);
return null;
}

return conn；
}

/**

* 将不再使用的连接返回给连接池

* @param con 客户程序释放的连接

*/
public synchronized void freeConnection(Connection conn) {

// 将指定连接加入到向量末尾
freeConnections.addElement(conn);
checkedOut--;
notifyAll();        //删除等待队列中的所有线程
}

/**

* 关闭所有连接

*/
public synchronized void release(){
Enumeration<Connection> allConnections=freeConnections.elements();
while (allConnections.hasMoreElements()){
Connection con = (Connection) allConnections.nextElement();
try{
con.close();
log("关闭连接池"+poolName+"中的一个连接")；
}catch(SQLException e){
log(e,"无法关闭连接池"+poolName+"中的连接")；
}
}
freeConnections.removeAllElements();

}

}

}

//测试类

/*

 * 

 * InforGuard Copyright 2008 CVICSE, Co.ltd . 

 * All rights reserved.

 * Package:  com.cvicse.util

 * FileName: Test.java

 */
 
package com.cvicse.util;

 

import java.sql.Connection;

public class Test {

 

/**

* @param args

*/
public static void main(String[] args) {

//文件流输入方式

DBConnectionManager connectionManager = DBConnectionManager.getInstance();

try{
Thread.sleep(10);
}catch(InterruptedException e){

// TODO Auto-generated catch block
e.printStackTrace();

}

Connection conn1 = connectionManager.getConnection("MySQL");

Connection conn2 = connectionManager.getConnection("mysql");

Connection conn3 = connectionManager.getConnection("mysql");

Connection conn4 = connectionManager.getConnection("mysql");

Connection conn5 = connectionManager.getConnection("mysql");

System.out.println(" conn1 == " + conn1);

System.out.println(" conn2 == " + conn2);

System.out.println(" conn3 == " + conn3);

System.out.println(" conn4 == " + conn4);

System.out.println(" conn5 == " + conn5);

 

connectionManager.freeConnection("mysql", conn1);

connectionManager.freeConnection("mysql", conn2);

connectionManager.freeConnection("mysql", conn3);

connectionManager.freeConnection("mysql", conn4);

connectionManager.freeConnection("mysql", conn5);

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block
e.printStackTrace();

}

Connection conn6 = connectionManager.getConnection("mysql");

Connection conn7 = connectionManager.getConnection("mysql");

Connection conn8 = connectionManager.getConnection("mysql");

Connection conn9 = connectionManager.getConnection("mysql");

Connection conn10 = connectionManager.getConnection("mysql");

System.out.println(" conn6 == " + conn6);

System.out.println(" conn7 == " + conn7);

System.out.println(" conn8 == " + conn8);

System.out.println(" conn9 == " + conn9);

System.out.println(" conn10 == " + conn10);

}

}