连接池Java

这里是我实现的连接池。将所有变量和方法都设置为静态是一个好的设计。请解释为什么或者为什么不

public class MyCp1 {

    private static final int MAX_SIZE=100;
    private static final BlockingQueue<Connection> bq;

    static{
         System.out.println("Inside begin static block" );
        bq= new ArrayBlockingQueue<Connection>(MAX_SIZE);
        for(int i=0;i<MAX_SIZE;i++)
        {
            try {
                try {
                    bq.put(makeConnection());
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        System.out.println("total size:" + bq.size());
    }

    public static Connection getConnection() throws InterruptedException
    {
        System.out.println("size before getting connection "+ bq.size()+ "  Thread name  "+ Thread.currentThread().getName());
        Connection con=bq.take();
        System.out.println("size after getting connection  "+ bq.size()+"  Thread name  "+ Thread.currentThread().getName());
        return (con);
    }

    public static boolean releaseConnection(Connection con) throws InterruptedException
    {
        System.out.println("size before releasing connection  "+ bq.size()+" Thread name  "+ Thread.currentThread().getName());
        boolean bool =bq.add(con);
        System.out.println("size after releasing connection  "+ bq.size()+"  Thread name  "+ Thread.currentThread().getName());
        return (bool);
    }

    public static Connection makeConnection() throws SQLException {
        Connection conn = null;
        Properties connectionProps = new Properties();
        connectionProps.put("user", "root");
        connectionProps.put("password", "java33");
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  
        conn = DriverManager.getConnection("jdbc:" + "mysql" + "://"
                + "localhost" + ":" + "3306" + "/test", connectionProps);

        System.out.println("Connected to database");
        return conn;
    }


}

 public class ConnectionPool {

    private static final int MAX_SIZE = 100;
    private    BlockingQueue<Connection> bq;
    private static ConnectionPool cp= new ConnectionPool();


    private ConnectionPool(){
        System.out.println("inside constructor");
         bq = new ArrayBlockingQueue<Connection>(MAX_SIZE);
        Properties connectionProps = new Properties();
        connectionProps.put("user", "root");
        connectionProps.put("password", "java33");
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (int i = 0; i < MAX_SIZE; i++) {
            try {
                bq.put(makeConnection(connectionProps));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        System.out.println("total size:" + bq.size());
    }
    public static ConnectionPool getInstance()
    {
        return cp;

    }

    public  Connection getConnection() throws InterruptedException {
        System.out.println("size before getting connection" + bq.size());
        Connection con = bq.take();
        System.out.println("size after getting connection" + bq.size());
        return (con);
    }

    public  void releaseConnection(Connection con)
            throws InterruptedException {
        System.out.println("size before releasing connection" + bq.size());
         bq.put(con);
        System.out.println("size after releasing connection" + bq.size());
        //return (bool);
    }

    private  Connection makeConnection(Properties connectionProps) throws SQLException {
        Connection conn = null;
        conn = DriverManager.getConnection("jdbc:" + "mysql" + "://"
                + "localhost" + ":" + "3306" + "/test", connectionProps);

        System.out.println("Connected to database");
        return conn;
    }

}

公共类MyCp1{
专用静态最终整数最大值=100；
私有静态最终阻塞队列bq；
静止的{
System.out.println（“内部开始静态块”）；
bq=新阵列锁定队列（最大大小）；
对于（inti=0；i绝对不是。你所拥有的更多的是一个对象回收器，如果你需要的话，这很好

 public class ConnectionPool {

    private static final int MAX_SIZE = 100;
    private    BlockingQueue<Connection> bq;
    private static ConnectionPool cp= new ConnectionPool();


    private ConnectionPool(){
        System.out.println("inside constructor");
         bq = new ArrayBlockingQueue<Connection>(MAX_SIZE);
        Properties connectionProps = new Properties();
        connectionProps.put("user", "root");
        connectionProps.put("password", "java33");
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (int i = 0; i < MAX_SIZE; i++) {
            try {
                bq.put(makeConnection(connectionProps));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        System.out.println("total size:" + bq.size());
    }
    public static ConnectionPool getInstance()
    {
        return cp;

    }

    public  Connection getConnection() throws InterruptedException {
        System.out.println("size before getting connection" + bq.size());
        Connection con = bq.take();
        System.out.println("size after getting connection" + bq.size());
        return (con);
    }

    public  void releaseConnection(Connection con)
            throws InterruptedException {
        System.out.println("size before releasing connection" + bq.size());
         bq.put(con);
        System.out.println("size after releasing connection" + bq.size());
        //return (bool);
    }

    private  Connection makeConnection(Properties connectionProps) throws SQLException {
        Connection conn = null;
        conn = DriverManager.getConnection("jdbc:" + "mysql" + "://"
                + "localhost" + ":" + "3306" + "/test", connectionProps);

        System.out.println("Connected to database");
        return conn;
    }

}

（但是，作为一个回收者，您仍然不需要静态字段，但您只需要创建一个回收者实例。）

 public class ConnectionPool {

    private static final int MAX_SIZE = 100;
    private    BlockingQueue<Connection> bq;
    private static ConnectionPool cp= new ConnectionPool();


    private ConnectionPool(){
        System.out.println("inside constructor");
         bq = new ArrayBlockingQueue<Connection>(MAX_SIZE);
        Properties connectionProps = new Properties();
        connectionProps.put("user", "root");
        connectionProps.put("password", "java33");
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (int i = 0; i < MAX_SIZE; i++) {
            try {
                bq.put(makeConnection(connectionProps));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        System.out.println("total size:" + bq.size());
    }
    public static ConnectionPool getInstance()
    {
        return cp;

    }

    public  Connection getConnection() throws InterruptedException {
        System.out.println("size before getting connection" + bq.size());
        Connection con = bq.take();
        System.out.println("size after getting connection" + bq.size());
        return (con);
    }

    public  void releaseConnection(Connection con)
            throws InterruptedException {
        System.out.println("size before releasing connection" + bq.size());
         bq.put(con);
        System.out.println("size after releasing connection" + bq.size());
        //return (bool);
    }

    private  Connection makeConnection(Properties connectionProps) throws SQLException {
        Connection conn = null;
        conn = DriverManager.getConnection("jdbc:" + "mysql" + "://"
                + "localhost" + ":" + "3306" + "/test", connectionProps);

        System.out.println("Connected to database");
        return conn;
    }

}

对于连接池（如果是JDBC连接），它需要是线程安全的，理想情况下不需要返回连接

 public class ConnectionPool {

    private static final int MAX_SIZE = 100;
    private    BlockingQueue<Connection> bq;
    private static ConnectionPool cp= new ConnectionPool();


    private ConnectionPool(){
        System.out.println("inside constructor");
         bq = new ArrayBlockingQueue<Connection>(MAX_SIZE);
        Properties connectionProps = new Properties();
        connectionProps.put("user", "root");
        connectionProps.put("password", "java33");
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (int i = 0; i < MAX_SIZE; i++) {
            try {
                bq.put(makeConnection(connectionProps));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        System.out.println("total size:" + bq.size());
    }
    public static ConnectionPool getInstance()
    {
        return cp;

    }

    public  Connection getConnection() throws InterruptedException {
        System.out.println("size before getting connection" + bq.size());
        Connection con = bq.take();
        System.out.println("size after getting connection" + bq.size());
        return (con);
    }

    public  void releaseConnection(Connection con)
            throws InterruptedException {
        System.out.println("size before releasing connection" + bq.size());
         bq.put(con);
        System.out.println("size after releasing connection" + bq.size());
        //return (bool);
    }

    private  Connection makeConnection(Properties connectionProps) throws SQLException {
        Connection conn = null;
        conn = DriverManager.getConnection("jdbc:" + "mysql" + "://"
                + "localhost" + ":" + "3306" + "/test", connectionProps);

        System.out.println("Connected to database");
        return conn;
    }

}

线程安全的连接池将用于返回仅在该线程上使用的连接。如果一个连接池不可用，它将通过实现来创建新连接

 public class ConnectionPool {

    private static final int MAX_SIZE = 100;
    private    BlockingQueue<Connection> bq;
    private static ConnectionPool cp= new ConnectionPool();


    private ConnectionPool(){
        System.out.println("inside constructor");
         bq = new ArrayBlockingQueue<Connection>(MAX_SIZE);
        Properties connectionProps = new Properties();
        connectionProps.put("user", "root");
        connectionProps.put("password", "java33");
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (int i = 0; i < MAX_SIZE; i++) {
            try {
                bq.put(makeConnection(connectionProps));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        System.out.println("total size:" + bq.size());
    }
    public static ConnectionPool getInstance()
    {
        return cp;

    }

    public  Connection getConnection() throws InterruptedException {
        System.out.println("size before getting connection" + bq.size());
        Connection con = bq.take();
        System.out.println("size after getting connection" + bq.size());
        return (con);
    }

    public  void releaseConnection(Connection con)
            throws InterruptedException {
        System.out.println("size before releasing connection" + bq.size());
         bq.put(con);
        System.out.println("size after releasing connection" + bq.size());
        //return (bool);
    }

    private  Connection makeConnection(Properties connectionProps) throws SQLException {
        Connection conn = null;
        conn = DriverManager.getConnection("jdbc:" + "mysql" + "://"
                + "localhost" + ":" + "3306" + "/test", connectionProps);

        System.out.println("Connected to database");
        return conn;
    }

}

此外，您的线程应该使用因此，您也可以重用线程。
无需编写连接池的实现。使用或。为什么要重新发明轮子？：）。请不要尝试重新发明如此重要的软件方面，例如连接池，只要您是Java新手，并且已经不知道何时使用
静态
。它迟早会杀死您。这是一个练习吗？我建议您使用
commons dbcp
或
c3p0
开源池。虽然使用连接池库比自己创建好，但通过正确编写自己的连接池库（或阅读上述库之一的源代码）可以学到很多东西.@CoolBeans-不要使用DBCP！这很可怕。例如，它会在尝试创建新连接时阻止尝试返回连接的线程。有很多方法可以使池线程安全。将连接专用于线程只是众多方法中的一种，这是最好的方法还是好的方法取决于circumstances。如果使用
Executors.newCachedThreadPool
，则方法中没有太多池，其中未使用的线程在60秒超时后死亡。
 public class ConnectionPool {

    private static final int MAX_SIZE = 100;
    private    BlockingQueue<Connection> bq;
    private static ConnectionPool cp= new ConnectionPool();


    private ConnectionPool(){
        System.out.println("inside constructor");
         bq = new ArrayBlockingQueue<Connection>(MAX_SIZE);
        Properties connectionProps = new Properties();
        connectionProps.put("user", "root");
        connectionProps.put("password", "java33");
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        for (int i = 0; i < MAX_SIZE; i++) {
            try {
                bq.put(makeConnection(connectionProps));
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

        System.out.println("total size:" + bq.size());
    }
    public static ConnectionPool getInstance()
    {
        return cp;

    }

    public  Connection getConnection() throws InterruptedException {
        System.out.println("size before getting connection" + bq.size());
        Connection con = bq.take();
        System.out.println("size after getting connection" + bq.size());
        return (con);
    }

    public  void releaseConnection(Connection con)
            throws InterruptedException {
        System.out.println("size before releasing connection" + bq.size());
         bq.put(con);
        System.out.println("size after releasing connection" + bq.size());
        //return (bool);
    }

    private  Connection makeConnection(Properties connectionProps) throws SQLException {
        Connection conn = null;
        conn = DriverManager.getConnection("jdbc:" + "mysql" + "://"
                + "localhost" + ":" + "3306" + "/test", connectionProps);

        System.out.println("Connected to database");
        return conn;
    }

}