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

最新推荐文章于 2024-08-18 00:20:30 发布
最新推荐文章于 2024-08-18 00:20:30 发布
阅读量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 58
数据库连接池的作用: 1． 资源重用 当多个用户频繁的去对数据库进行读写操作时,会不间断的创建Connection,在数据库开始读写数据之前,把资源过多的分配给创建连接释放连接上,这笔开销得不偿失.数据库连接池的对连接Connection的资源回收机制对此做出了优化 2． 更快的系统响应速度 数据库连接池一旦初始化,用户获取的Connection不再创建新的,而是从现...
MySQL 并发教程（一）
最新发布
龙哥盟
08-18 894
就数据库而言，并发和锁定是一些最复杂的主题。当条件“刚刚好”时，通常执行快速且没有问题的查询可能会突然花费更长时间或失败并出现错误，因此锁定或争用成为一个问题。你可能会问自己，为什么锁会引起这样的问题。这一章和接下来的 11 章将试图解释这一点，以及你如何最好地处理它们。本书的最后六章通过六个案例研究，将现实场景中的信息与分析以及如何避免或减少问题结合在一起。在这一章中，你将首先学习为什么锁是重要的，尽管它们会引起一些问题。然后将解释与事务的关系。
一个简单的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 311
当我们访问一个网站的时候，每访问一次都要连接该网站的数据库，这样每一次连接的创建和释放都消耗很大的服务器性能，所以就得有一个更好的数据库连接技术来解决这个性能问题。 以下只是实现了简单的创建连接，获得连接，释放连接，用来理解数据库连接池的原理 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 396
来想象这样一个场景，一天，公司 CEO 把你叫到会议室，告诉你公司看到了一个新的商业机会，希望你能带领一名兄弟，迅速研发出一套面向某个垂直领域的电商系统。 在人手紧张，时间不足的情况下，为了能够完成任务，你毫不犹豫地采用了最简单的架构：前端一台 Web 服务器运行业务代码，后端一台数据库服务器存储业务数据。 这个架构图是我们每个人最熟悉的，最简单的架构原型，很多系统在一开始都是长这样的，只是随着业务复杂度的提高，架构做了叠加，然后看起来就越来越复杂了。 再说回我们的垂直电商系统，系统一开始上线之后，虽然用
mysql+连接池+推荐_简单的MySQL连接池，支持高并发。
weixin_42353258的博客
01-21 252
下面是编程之家 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 947
在配置application.yml时，对hikari的配置会有这样一个字段validationQuery。 validationQuery是用来验证数据库连接的查询语句，这个查询语句必须是至少返回一条数据的SELECT语句。每种数据库都有各自的验证语句。 DataBase validationQuery hsqldb select 1 from INFORMATION...
掌握MySQL事务与连接池基础：原子性、隔离性和控制
合理的连接池管理可以减少数据库连接创建和关闭的开销，同时保证在高并发情况下事务的顺利进行。 总结来说，本文提供了一个基础的框架，帮助读者了解MySQL事务的概念、控制方式以及隔离级别的重要性，并通过实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值