简单的MySQL连接池，支持高并发。

最新推荐文章于 2021-09-05 23:32:48 发布
最新推荐文章于 2021-09-05 23:32:48 发布
阅读量1.8k 收藏 1
点赞数 1
分类专栏： java 文章标签： java 
/**
 * 连接池类
 */
package com.junones.test;
 
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
 
import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
 
public class MySQLPool {
    private static volatile MySQLPool pool;
    private MysqlDataSource ds;
    private Map<Connection, Boolean> map;
  
    private String url = "jdbc:mysql://localhost:3306/test";
    private String username = "root";
    private String password = "root1234";
    private int initPoolSize = 10;
    private int maxPoolSize = 200;
    private int waitTime = 100;
     
    private MySQLPool() {
        init();
    }
     
    public static MySQLPool getInstance() {
        if (pool == null) {
            synchronized (MySQLPool.class) {
                if(pool == null) {
                    pool = new MySQLPool();
                }
            }
        }
        return pool;
    }
     
    private void init() {
        try {
            ds = new MysqlDataSource();
            ds.setUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            ds.setCacheCallableStmts(true);
            ds.setConnectTimeout(1000);
            ds.setLoginTimeout(2000);
            ds.setUseUnicode(true);
            ds.setEncoding("UTF-8");
            ds.setZeroDateTimeBehavior("convertToNull");
            ds.setMaxReconnects(5);
            ds.setAutoReconnect(true);
            map = new HashMap<Connection, Boolean>();
            for (int i = 0; i < initPoolSize; i++) {
                map.put(getNewConnection(), true);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     
    public Connection getNewConnection() {
        try {
            return ds.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
     
    public synchronized Connection getConnection() {
        Connection conn = null;
        try {
            for (Entry<Connection, Boolean> entry : map.entrySet()) {
                if (entry.getValue()) {
                    conn = entry.getKey();
                    map.put(conn, false);
                    break;
                }
            }
            if (conn == null) {
                if (map.size() < maxPoolSize) {
                    conn = getNewConnection();
                    map.put(conn, false);
                } else {
                    wait(waitTime);
                    conn = getConnection();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }
     
    public void releaseConnection(Connection conn) {
        if (conn == null) {
            return;
        }
        try {
            if(map.containsKey(conn)) {
                if (conn.isClosed()) {
                    map.remove(conn);
                } else {
                    if(!conn.getAutoCommit()) {
                        conn.setAutoCommit(true);
                    }
                    map.put(conn, true);
                }
            } else {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
 
/**
 * 测试类
 */
package com.junones.test;
 
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
public class TestMySQLPool {
    private static volatile int a;
 
    private synchronized static void incr() {
        a++;
    }
 
    public static void main(String[] args) throws InterruptedException {
        int times = 10000;
        long start = System.currentTimeMillis();
        for (int i = 0; i < times; i++) {
            new Thread(new Runnable() {
 
                @Override
                public void run() {
 
                    MySQLPool pool = MySQLPool.getInstance();
                    Connection conn = pool.getConnection();
                    Statement stmt = null;
                    ResultSet rs = null;
                    try {
                        stmt = conn.createStatement();
                        rs = stmt.executeQuery("select id, name from t_test");
                        while (rs.next()) {
                            System.out.println(rs.getInt(1) + ", "
                                    + rs.getString(2));
                        }
                    } catch (SQLException e) {
                        e.printStackTrace();
                    } finally {
                        incr();
                        if (rs != null) {
                            try {
                                rs.close();
                            } catch (SQLException e) {
                                e.printStackTrace();
                            }
                        }
                        if (stmt != null) {
                            try {
                                stmt.close();
                            } catch (SQLException e) {
                            }
                        }
                        pool.releaseConnection(conn);
                    }
                }
            }).start();
        }
        while (true) {
            if (a == times) {
                System.out.println("finished, time:"
                        + (System.currentTimeMillis() - start));
                break;
            }
            Thread.sleep(100);
        }
    }
}
 
测试结果： 1万个并发， 5秒完成。
/**
  * 连接池类
  */
package com.junones.test;
 
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
 
import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
 
public class MySQLPool {
     private static volatile MySQLPool pool;
     private MysqlDataSource ds;
     private Map<Connection, Boolean> map;
  
     private String url = "jdbc:mysql://localhost:3306/test" ;
     private String username = "root" ;
     private String password = "root1234" ;
     private int initPoolSize = 10 ;
     private int maxPoolSize = 200 ;
     private int waitTime = 100 ;
     
     private MySQLPool() {
         init();
     }
     
     public static MySQLPool getInstance() {
         if (pool == null ) {
             synchronized (MySQLPool. class ) {
                 if (pool == null ) {
                     pool = new MySQLPool();
                 }
             }
         }
         return pool;
     }
     
     private void init() {
         try {
             ds = new MysqlDataSource();
             ds.setUrl(url);
             ds.setUser(username);
             ds.setPassword(password);
             ds.setCacheCallableStmts( true );
             ds.setConnectTimeout( 1000 );
             ds.setLoginTimeout( 2000 );
             ds.setUseUnicode( true );
             ds.setEncoding( "UTF-8" );
             ds.setZeroDateTimeBehavior( "convertToNull" );
             ds.setMaxReconnects( 5 );
             ds.setAutoReconnect( true );
             map = new HashMap<Connection, Boolean>();
             for ( int i = 0 ; i < initPoolSize; i++) {
                 map.put(getNewConnection(), true );
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
     
     public Connection getNewConnection() {
         try {
             return ds.getConnection();
         } catch (SQLException e) {
             e.printStackTrace();
         }
         return null ;
     }
     
     public synchronized Connection getConnection() {
         Connection conn = null ;
         try {
             for (Entry<Connection, Boolean> entry : map.entrySet()) {
                 if (entry.getValue()) {
                     conn = entry.getKey();
                     map.put(conn, false );
                     break ;
                 }
             }
             if (conn == null ) {
                 if (map.size() < maxPoolSize) {
                     conn = getNewConnection();
                     map.put(conn, false );
                 } else {
                     wait(waitTime);
                     conn = getConnection();
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return conn;
     }
     
     public void releaseConnection(Connection conn) {
         if (conn == null ) {
             return ;
         }
         try {
             if (map.containsKey(conn)) {
                 if (conn.isClosed()) {
                     map.remove(conn);
                 } else {
                     if (!conn.getAutoCommit()) {
                         conn.setAutoCommit( true );
                     }
                     map.put(conn, true );
                 }
             } else {
                 conn.close();
             }
         } catch (SQLException e) {
             e.printStackTrace();
         }
     }
}
 
/**
  * 测试类
  */
package com.junones.test;
 
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
public class TestMySQLPool {
     private static volatile int a;
 
     private synchronized static void incr() {
         a++;
     }
 
     public static void main(String[] args) throws InterruptedException {
         int times = 10000 ;
         long start = System.currentTimeMillis();
         for ( int i = 0 ; i < times; i++) {
             new Thread( new Runnable() {
 
                 @Override
                 public void run() {
 
                     MySQLPool pool = MySQLPool.getInstance();
                     Connection conn = pool.getConnection();
                     Statement stmt = null ;
                     ResultSet rs = null ;
                     try {
                         stmt = conn.createStatement();
                         rs = stmt.executeQuery( "select id, name from t_test" );
                         while (rs.next()) {
                             System.out.println(rs.getInt( 1 ) + ", "
                                     + rs.getString( 2 ));
                         }
                     } catch (SQLException e) {
                         e.printStackTrace();
                     } finally {
                         incr();
                         if (rs != null ) {
                             try {
                                 rs.close();
                             } catch (SQLException e) {
                                 e.printStackTrace();
                             }
                         }
                         if (stmt != null ) {
                             try {
                                 stmt.close();
                             } catch (SQLException e) {
                             }
                         }
                         pool.releaseConnection(conn);
                     }
                 }
             }).start();
         }
         while ( true ) {
             if (a == times) {
                 System.out.println( "finished, time:"
                         + (System.currentTimeMillis() - start));
                 break ;
             }
             Thread.sleep( 100 );
         }
     }
}
 
测试结果： 1 万个并发， 5 秒完成。
我来了007
关注
专栏目录
Druid简单高性能MySQL连接池
05-20
用阿里巴巴Druid实现的一个简单连接池，高性能，高并发。
用于App服务端的MySQL连接池（支持高并发）
09-10
为了支持高并发，连接池还需要具备以下关键特性： 1. **连接池的大小管理**：根据并发用户数动态调整连接池大小，避免过多的连接占用资源，同时确保有足够的连接满足请求。 2. **连接的健康检查**：定期检查并移除...
实现一个简易的数据库连接池
weixin_30367945的博客
08-06 57
数据库连接池的作用: 1． 资源重用 当多个用户频繁的去对数据库进行读写操作时,会不间断的创建Connection,在数据库开始读写数据之前,把资源过多的分配给创建连接释放连接上,这笔开销得不偿失.数据库连接池的对连接Connection的资源回收机制对此做出了优化 2． 更快的系统响应速度 数据库连接池一旦初始化,用户获取的Connection不再创建新的,而是从现...
一个简单的MySql数据库连接池的实现
weixin_30808253的博客
03-28 98
package cn.hc.connectionPool; import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.uti...
实现一个简单的数据库连接池
sololin_66的博客
11-03 145
转自
MySQL连接池与高并发：连接池在高并发场景下的应用的权威指南
[MySQL连接池与高并发：连接池在高并发场景下的应用的权威指南](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7f3fcab5293a4fecafe986050f2da992~tplv-k3u1fbpfcp-zoom-in-crop-mark:1512:0:0:0.awebp?...
MySQL连接池优化高并发应用性能：从入门到精通
[MySQL连接池优化高并发应用性能：从入门到精通](https://img-blog.csdnimg.cn/022239d6d31140109f658e8b32a8830e.png) # 1. MySQL连接池概述** MySQL连接池是一种资源管理机制，它通过预先创建和管理一组数据库...
MySql连接池支持库1.02.0版(Mysql_Connet.fne)-易语言
06-13
易语言的"MySql_Connect.fne"是一个专为易语言设计的MySQL连接池支持库，版本1.02.0，用于在Windows操作系统下进行多线程MySQL操作。 首先，我们要理解什么是连接池。连接池是数据库连接的一种管理机制，它维护着一...
自己实现简单的数据库连接池
gzx的博客
11-13 309
当我们访问一个网站的时候，每访问一次都要连接该网站的数据库，这样每一次连接的创建和释放都消耗很大的服务器性能，所以就得有一个更好的数据库连接技术来解决这个性能问题。 以下只是实现了简单的创建连接，获得连接，释放连接，用来理解数据库连接池的原理 public class MyDataSource {  // 两个数据库连接池  // 一个空闲连接池，一个正在使用的连接池  pr
一个Demo小例子让你了解数据库连接池实现的4种方式
12-14
一个Demo小例子让你了解数据库连接池实现的4种方式
自定义高并发jdbc连接池
06-23
自定义的JDBC连接池，支持并发访问，可维持多个数据库的连接池
Druid数据库连接池使用
lz313055150的专栏
01-07 111
1. 纯Java代码创建 dataSource = new DruidDataSource(); dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUsername("root"); dataSource.setPassword("11111111"); dataSource.setUrl("jd...
高并发系统设计六（池化技术）
qq_36341209的博客
09-05 394
来想象这样一个场景，一天，公司 CEO 把你叫到会议室，告诉你公司看到了一个新的商业机会，希望你能带领一名兄弟，迅速研发出一套面向某个垂直领域的电商系统。 在人手紧张，时间不足的情况下，为了能够完成任务，你毫不犹豫地采用了最简单的架构：前端一台 Web 服务器运行业务代码，后端一台数据库服务器存储业务数据。 这个架构图是我们每个人最熟悉的，最简单的架构原型，很多系统在一开始都是长这样的，只是随着业务复杂度的提高，架构做了叠加，然后看起来就越来越复杂了。 再说回我们的垂直电商系统，系统一开始上线之后，虽然用
mysql+连接池+推荐_简单的MySQL连接池，支持高并发。
weixin_42353258的博客
01-21 251
下面是编程之家 jb51.cc 通过网络收集整理的代码片段。编程之家小编现在分享给大家，也给大家做个参考。简单的MySQL连接池，用于App服务端比较合适/*** 连接池类*/package com.junones.test;import java.sql.Connection;import java.sql.SQLException;import java.util.HashMap;import...
mysql连接池 高并发_【转帖】置高并发jdbc连接池
weixin_36320737的博客
02-07 332
简单的MySQL连接池name="jdbc/TestDB"factory="org.apache.tomcat.jdbc.pool.DataSourceFactory"driverClassName="com.mysql.jdbc.Driver"url="jdbc:mysql://localhost:3306/mysql"username="mysql_user"password="mypassw...
连接池预热:
wenxi2367的博客
02-05 717
连接池预热:客户端循环ping服务端,不马上关闭连接,之后统一关闭. jedis.close()的含义是还回连接到连接池
性能超过DRUID的最强数据库连接池——HikariCP相关配置及简单示例
dfay89490的博客
07-05 945
在配置application.yml时，对hikari的配置会有这样一个字段validationQuery。 validationQuery是用来验证数据库连接的查询语句，这个查询语句必须是至少返回一条数据的SELECT语句。每种数据库都有各自的验证语句。 DataBase validationQuery hsqldb select 1 from INFORMATION...
mysql pool_mysql中的connection pool是什么
weixin_29014237的博客
01-25 607
mysql中的connection pool是什么发布时间：2020-06-24 15:41:08来源：亿速云阅读：189作者：Leah今天就跟大家聊聊有关mysql中的connection pool是什么，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。connection pool即数据库连接池，表示在程序启动时建立足够的数据库连接，并将这...
掌握MySQL事务与连接池基础：原子性、隔离性和控制
合理的连接池管理可以减少数据库连接创建和关闭的开销，同时保证在高并发情况下事务的顺利进行。 总结来说，本文提供了一个基础的框架，帮助读者了解MySQL事务的概念、控制方式以及隔离级别的重要性，并通过实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值