深度剖析池化技术内幕---高性能底层组件探秘

最新推荐文章于 2024-09-02 09:54:26 发布
最新推荐文章于 2024-09-02 09:54:26 发布
阅读量199 收藏 1
点赞数
分类专栏： Architectur-Design 文章标签： 池化技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/G0_hw/article/details/98522015
版权

    JDK中有常量池，线程池，数据库操作有连接池，那么这些池到底是什么？有什么作用？底层原理是啥？下面以连接池示例。

测试环境：JDK1.8 + MySQL8.0.16 + Spring Boot 2.1.3.RELEASE + Gradle 4.4.1

一. 从一个最原始的JDBC查询开始

  • build.gralde 加入相关依赖
// 依赖列表
dependencies {
    compile 'org.springframework.boot:spring-boot-starter-web'
    compile 'mysql:mysql-connector-java:8.0.16'
    testCompile 'org.springframework.boot:spring-boot-starter-test'
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compileOnly 'org.projectlombok:lombok:1.18.4'
}
  • application.yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/zzxypm?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true&serverTimezone=UTC
    username: root
    password: root
  • 数据源配置参数
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author wanghong
 * @date 2019/08/18 14:58
 **/
@Data
@Component
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceConfig {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
}
  • 原生JDBC操作工具类
package com.hong.util;

import com.hong.config.DataSourceConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author wanghong
 * @date 2019/08/18 14:11
 **/
@Component
public class JDBCUtil {

    @Autowired
    private DataSourceConfig dataSourceConfig;

    /**
     * 获取数据库连接
     *
     * @return
     * @throws SQLException
     */
    public Connection getConnection() throws SQLException {
        try {
            Class.forName(dataSourceConfig.getDriverClassName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return DriverManager.getConnection(dataSourceConfig.getUrl(), dataSourceConfig.getUsername(), dataSourceConfig.getPassword());
    }

    /**
     * * 关闭资源
     * * @param resultSet 查询返回的结果集，没有为空
     * * @param statement
     * * @param connection
     */
    public void close(ResultSet resultSet, Statement statement, Connection connection) {

        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }

    /**
     * 增加，删除，修改
     */
    public void insertOrDeleteOrUpdate(String sql) {
        try {
            Connection connection = getConnection();
            PreparedStatement pst = connection.prepareStatement(sql);
            int execute = pst.executeUpdate();
            System.out.println("执行语句：" + sql + "," + execute + "行数据受影响");
            close(null, pst, connection);
        } catch (SQLException e) {
            System.out.println("异常提醒：" + e);
        }
    }

    /**
     * * 查询，返回结果集
     */
    public List<Map<String, Object>> select(String sql) {
        List<Map<String, Object>> returnResultToList = null;
        try {
            Connection connection = getConnection();
            PreparedStatement pst = connection.prepareStatement(sql);
            ResultSet resultSet = pst.executeQuery();
            returnResultToList = returnResultToList(resultSet);
            close(resultSet, pst, connection);
        } catch (SQLException e) {
            System.out.println("异常提醒：" + e);
        }
        return returnResultToList;
    }

    /**
     * 数据返回集合
     *
     * @param resultSet
     * @return
     * @throws SQLException
     */
    private List<Map<String, Object>> returnResultToList(ResultSet resultSet) {
        List<Map<String, Object>> values = null;
        try {
            // 键: 存放列的别名, 值: 存放列的值.
            values = new ArrayList<>();
            // 存放字段名
            List<String> columnName = new ArrayList<>();
            ResultSetMetaData rsmd = resultSet.getMetaData();
            for (int i = 0; i < rsmd.getColumnCount(); i++) {
                // 字段名
                columnName.add(rsmd.getColumnLabel(i + 1));
            }
            System.out.println("表字段为：");
            System.out.println(columnName);
            System.out.println("表数据为：");
            Map<String, Object> map = null;
            // 处理 ResultSet, 使用 while 循环
            while (resultSet.next()) {
                map = new HashMap<>();
                for (String column : columnName) {
                    Object value = resultSet.getObject(column);
                    map.put(column, value);
                    System.out.print(value + "\t");
                }
                // 把一条记录的 Map 对象放入准备的 List 中
                values.add(map);
                System.out.println();
            }
        } catch (SQLException e) {
            System.out.println("异常提醒：" + e);
        }
        return values;
    }

}

@Service
public class JdbcService {
    @Autowired
    private JDBCUtil jdbcUtil;

    /**
     * 数据库操作
     * @param sql
     */
    public List<Map<String, Object>> execute(String sql){
        List<Map<String, Object>> list = jdbcUtil.select(sql);
        return list;
    }
}

@Controller
public class HelloController {

    @Autowired
    private JdbcService jdbcService;

    @GetMapping("/")
    @ResponseBody
    public Object Home() {
        String sql = "SELECT * FROM t_user WHERE account = 'wanghong'";
        return jdbcService.execute(sql);
    }

}

在这里插入图片描述
好了，可以正常访问。下面模拟下并发查询。

二. 多线程并发操作
改造下service代码如下：

package com.hong.service;

import com.hong.util.JDBCUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

/**
 * @author wanghong
 * @date 2019/08/18 12:09
 **/
@Service
public class JdbcService {

    private static final int CONCURRENCY_LEVEL = 200; // 模拟并发请求

    @Autowired
    private JDBCUtil jdbcUtil;

    /**
     * 数据源连接压测
     */
    public void benchmarkTest() {
        String sql = "SELECT * FROM t_user WHERE account = 'wanghong'";
        CountDownLatch cdl = new CountDownLatch(CONCURRENCY_LEVEL);
        for (int i = 0; i < CONCURRENCY_LEVEL; i++) {
            // 多线程模拟客户端并发查询请求
            Thread thread = new Thread(() -> {
                try {
                    // 代码在这里等待CountDownLatch计数为0，代表所有线程可以start，再同时抢占运行
                    cdl.await();
                    execute(sql);
                } catch (InterruptedException e) {
                    System.out.println(Thread.currentThread().getName() + "线程执行出现异常:" + e.getMessage());
                }
            });
            thread.setName("jdbc-thread-" + i);
            thread.start();
            //线程启动后，倒记数器-1，表示又有一个线程就绪了
            cdl.countDown();
        }
    }

    /**
     * 数据库操作
     * @param sql
     */
    public List<Map<String, Object>> execute(String sql){
        List<Map<String, Object>> list = jdbcUtil.select(sql);
        return list;
    }
}

@Controller
public class HelloController {

    @Autowired
    private JdbcService jdbcService;

    @GetMapping("/")
    @ResponseBody
    public Object Home() {
       // String sql = "SELECT * FROM t_user WHERE account = 'wanghong'";
       // return jdbcService.execute(sql);
        jdbcService.benchmarkTest();
        return null;
    }
}

发送请求，然后控制台出现了如下异常信息：

java.sql.SQLNonTransientConnectionException: Data source rejected establishment of connection,  message from server: "Too many connections"

下面看看如何使用池化技术解决数据库连接的问题。

三. 池？

  • 池是什么？
    在这里插入图片描述
  • 池化技术有哪些共性？
    在这里插入图片描述
  • 什么样的资源需要池化？
    在这里插入图片描述

四. 如何设计一个池？

  • 设计实现
    在这里插入图片描述
    在这里插入图片描述

  • 技术内幕 — AtomicInteger CAS
    在这里插入图片描述

  • 技术内幕 — Condition
    在这里插入图片描述

  • 代码落地

package com.hong.config;

import java.sql.Connection;

/**
 * @author wanghong
 * @date 2019/08/18 16:21
 *  数据库连接池定义
 **/
public interface ConnectionPool {

    /**
     *  初始化
     * @param initSize 初始化连接数
     * @param maxActive 最大连接数
     * @param idleCount 空闲连接数
     * @param waitTime 获取连接超时时间
     */
    void init(int initSize ,int maxActive ,int idleCount,long waitTime);

    /**
     * 获取连接
     * @return
     */
    Connection get();

    /**
     * 回收资源
     * @param conn
     */
    void recycle(Connection conn);
}

package com.hong.config;

import com.hong.util.JDBCUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author wanghong
 * @date 2019/08/18 16:29
 * 连接池组件实现
 **/
@Component
public class ConnectionPoolImpl implements ConnectionPool {

    @Autowired
    private JDBCUtil jdbcUtil;

    private int initSize;
    private int maxActive;
    private int idleCount;
    private long waitTime;

    // 当前活动的线程数
    private AtomicInteger activeSize = new AtomicInteger();

    BlockingQueue<Connection> idle;
    BlockingQueue<Connection> busy;

    @Override
    public void init(int initSize, int maxActive, int idleCount, long waitTime) {
        // 省略参数检查
        this.initSize = initSize;
        this.maxActive = maxActive;
        this.idleCount = idleCount;
        this.waitTime = waitTime;

        idle = new LinkedBlockingDeque<>();
        busy = new LinkedBlockingDeque<>();

        initConnection(this.initSize);
    }

    /**
     * 初始化数据库连接
     *
     * @param initSize
     */
    private void initConnection(int initSize) {
        for (int i = 0; i < initSize; i++) {
            if (activeSize.get() < maxActive){
                // 双重检查
                if (activeSize.incrementAndGet() <= maxActive){
                    try {
                        Connection conn = jdbcUtil.getConnection();
                        idle.offer(conn);
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }else {
                    activeSize.decrementAndGet();
                }
            }
        }
    }

    @Override
    public Connection get() {
        long start = System.currentTimeMillis();
        // 1. 从空闲组获取
        Connection conn = idle.poll();
        if (conn != null){
            System.out.println("从空闲组获得连接");
            busy.offer(conn);
            return conn;
        }

        // 2. 空闲组没有，没有限制
        if (activeSize.get() < maxActive){
            if (activeSize.incrementAndGet() <= maxActive){
                System.out.println("创建一个新的连接");
                try{
                    conn = jdbcUtil.getConnection();
                    busy.offer(conn);
                    return conn;
                }catch (Exception e){
                    System.out.println("获取连接异常：" + e);
                }
            }else {
                activeSize.decrementAndGet();
            }
        }

        // 3.连接全忙，等待连接归还
        long timeout = waitTime - (System.currentTimeMillis() - start);
        try {
            conn = idle.poll(timeout, TimeUnit.MILLISECONDS);
            if (conn == null){
                throw new TimeoutException("等待获取连接超时，等待时间为：" + timeout + "ms");
            }
        } catch (InterruptedException | TimeoutException e) {
            e.printStackTrace();
            Thread.interrupted();
        }
        return conn;
    }

    @Override
    public void recycle(Connection conn) {
        if (conn == null){
            return;
        }

        // 从busy挪到idle
        boolean removed = busy.remove(conn);
        if (removed){
            // 空闲连接太多，释放掉
            if (idleCount < idle.size()){
                jdbcUtil.close(null,null,conn);
                activeSize.decrementAndGet();
                return;
            }

            boolean offerd = idle.offer(conn);
            // 没有放入成功
            if (!offerd){
                jdbcUtil.close(null,null,conn);
                activeSize.decrementAndGet();
            }
        }else {
            // 不在组中，关闭释放连接，防止连接泄露
            jdbcUtil.close(null,null,conn);
            activeSize.decrementAndGet();
        }
    }
}

package com.hong.util;

import com.hong.config.ConnectionPool;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/**
 * @author wanghong
 * @date 2019/08/18 17:20
 **/
@Component
public class JDBCDao {

    @Autowired
    private ConnectionPool connectionPool;

    @Autowired
    private JDBCUtil jdbcUtil;

    /**
     * 注解@PostConstruct与@PreDestroy
     *
     * PostConstruct 用于在依赖关系注入完成之后需要执行的方法上，以执行任何初始化。
     */
    @PostConstruct
    private void init(){
        connectionPool.init(10,100,10,5000);
    }

    public List<Map<String, Object>> select(String sql) {
        List<Map<String, Object>> returnResultToList = null;
        try {
            // 从连接池中获取连接
            Connection connection = connectionPool.get();
            PreparedStatement pst = connection.prepareStatement(sql);
            ResultSet resultSet = pst.executeQuery();
            returnResultToList = jdbcUtil.returnResultToList(resultSet);
            // 使用完，将连接放回连接池
            connectionPool.recycle(connection);
        } catch (SQLException e) {
            System.out.println("异常提醒：" + e);
        }
        return returnResultToList;
    }
}

JdbcService.java

    /**
     * 数据库操作
     * @param sql
     */
    public List<Map<String, Object>> execute(String sql){
       // List<Map<String, Object>> list = jdbcUtil.select(sql);
        List<Map<String, Object>> list = jdbcDao.select(sql);
        return list;
    }

请求测试，没有再报之前的异常了。

G0_hw
关注
专栏目录
Java GenericObjectPool 对象池化技术--SpringBoot sftp 连接池工具类
20年码农
04-07 2304
通常一个对象创建、销毁非常耗时的时候，我们不会频繁的创建和销毁它，而是考虑复用。复用对象的一种做法就是对象池，将创建好的对象放入池中维护起来，下次再用的时候直接拿池中已经创建好的对象继续用，这就是池化的思想。Apache Commons Pool是一个对象池的框架，他提供了一整套用于实现对象池化的API。
Spring boot核心技术(一)
热门推荐
飞奔的波大爷的博客
01-27 1万+
上一章节Spring boot入门， http://blog.csdn.net/qq_22860341/article/details/78930813 本章主要介绍spring boot的核心。 *Spring 核心功能 *Spring 配置 Spring 核心功能 1. 独立运行的spring 项目 Spring Boot可以以jar的形式独立运行，运行一个Sprin
Java 高性能队列底层到底是什么？
GitChat
07-29 631
本 Chat 解析市面上常见的 Java 优秀队列中的底层存储技术细节。 通过本 Chat ，你可以学习到： 我司自研队列的底层高速存储细节 RocketMQ 底层存储细节 Kafka 底层存储细节 我们都知道 Kafka，RocketMQ 速度快，那么到底为什么块，细节是什么，大部分文章都不会去关注，本 Chat 不讲概念，让你实实在在看到实现细节的分析和代码。...
SpringBoot整合common-pool2实现对象池
爱码猿的博客
10-16 3454
使用池化主要是为了节省对象创建和销毁的开销。比如日常开发息息相关的数据源连接池，就是为了减少连接创建的时间而生的。commons-pool是apacha基金会开源的一款常见的对象池工具库。springBoot整合common-pool实现对象池。
资源池以及资源池化是什么意思？
行云管家
07-22 7423
资源池是什么意思？资源池化是什么意思？相信有很多刚入行的运维人员不是很了解，下面我们就一起看看。
探秘Windows进程魔法：Process-Magics深度剖析与推荐
gitblog_00061的博客
05-31 756
探秘Windows进程魔法：Process-Magics深度剖析与推荐 Process-Magics This is a collection of interesting codes about Windows Process creation. 项目地址: h...
探秘大数据的宇宙 —— bigdata-hub项目深度剖析
gitblog_00028的博客
06-08 896
探秘大数据的宇宙 —— bigdata-hub项目深度剖析 去发现同类优质开源项目:https://gitcode.com/ 在大数据洪流涌动的时代，如何高效地管理和分析海量数据成为了一项至关重要的技能。今天，我们将一起探索一个汇聚了大数据领域精华的开源宝藏——bigdata-hub。这不仅仅是一个项目，更是一扇通往数据科学广阔世界的门户。 项目介绍 bigdata-hub是为了解锁大数据领域的无...
探秘Apache NetBeans Maven插件：nbm-maven-plugin深度剖析
最新发布
gitblog_00868的博客
09-02 594
探秘Apache NetBeans Maven插件：nbm-maven-plugin深度剖析 netbeans-mavenutils-nbm-sharedApache NetBeans Maven Utils NBM-Shared 是一个用于共享 Apache NetBeans Maven 插件的通用代码的库。它包含了许多用于处理 Maven 插件的通用代码，如解析 POM 文件、处理依赖关系、...
探秘802.11ac 2.0：MU-MIMO技术助力解决Wi-Fi网络拥塞
01-19
多用户多重输入多重输出（MU-MIMO）技术能使信号发送存取点（AP）同时服务多个用户端装置，而采用此技术的802.11ac 2.0标准，则能藉此实现比前一代规格快三倍左右的联网速度，大幅提升Wi-Fi装置的服务品质。...
探秘zzw-springboot项目：深度剖析SpringBoot底层机制
本项目旨在探讨Spring Boot底层机制的实现原理，具体分析Spring Boot自动配置、启动流程、核心组件等方面的工作原理。 首先，Spring Boot的自动配置是其一大亮点，它能够根据项目中添加的jar依赖情况自动配置Spring...
Objective-C 运行时魔法：动态方法解析与消息机制深度探秘
06-21
Objective-C（通常缩写为Obj-C或简称OC）是一种面向对象的编程语言，它建立在C语言的基础上，并添加了面向对象的特性。Objective-C最初由Brad Cox和Tom Love在1980年代早期开发，后来被苹果公司采用，成为macOS和iOS...
通信与网络中的探秘802.11ac 2.0：MU-MIMO技术助力解决Wi-Fi网络拥塞
10-19
多用户多重输入多重输出（MU-MIMO）技术能使信号发送存取点（AP）同时服务多个用户端装置，而采用此技术的802.11ac 2.0标准，则能藉此实现比前一代规格快三倍左右的联网速度，大幅提升Wi-Fi装置的服务品质。...
入门深度学习--探秘lstm
01-06
入门深度学习--探秘LSTM 深度学习是人工神经网络的一种，通过不断地学习和训练，神经网络可以自动校正权重、偏置等参数，以拟合更好的学习效果。深度学习广泛应用于图像识别、语音、自然语言等领域。 深度学习的...
基于Redis生成递增序号
G0_hw
07-31 4530
一. Spring Boot + Redisson 生成运单号 <!--整合redission框架start--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </de
基于Spring Boot + Redis实现接口幂等性
G0_hw
05-26 626
https://mp.weixin.qq.com/s/2vycQljbC-DZYZgUtAQiXQ https://mp.weixin.qq.com/s/v_iyZVd5ldixnhaxkdSArA https://mp.weixin.qq.com/s/xy4Jg3LrK0dpYy5q4rAAaw https://mp.weixin.qq.com/s/8t8eNRSMLBgjeQBfnfxZIQ
高性能系统优化--请求合并让性能提升数十倍
G0_hw
05-06 490
注解+反射实现动态调用
G0_hw
07-30 404
一. 业务场景说明     微服务开发，有两个独立的应用服务：a 和 b，a是聚合入口服务，单向调用关系，即 a -> b。又有一个开放平台服务c，需要先调用a，然后再a中回调通知b。但开发平台回调通知的时间有很多，在a中不想对每一个通知时间都写一个方法rest接口来接收，而是想用一个rest方法统一收归开放平台的各种通知，然后根据通知类型分派到b中不同的api里，这样保证了a作为聚合入口服务的纯粹性，开放平台也只需要和a的这一个统一收归的接口交互，真正的业务处
分布式锁应用与实践
G0_hw
01-13 303
一.为什么需要分布式锁 场景描述：小型电商网站，下单，生产有一定业务含义的唯一订单编号 如2019-01-12-23:00:00-01 OrderService(订单服务类) ----&amp;amp;amp;amp;amp;gt;OrderCodeGenerator(订单编号生成类) package com.hong.order; import java.time.LocalDateTime; import java.time.fo...
RPC实践
G0_hw
06-05 291
一. RPC是什么？ remote procedure call,远程过程调用。其中远程表示不同应用间的调用，过程就是业务处理，计算任务，更直白理解，就是程序(像调用本地方法一样调用远程的过程)。 RPC采用Client-Server结构，通过request-response消息模式实现。 RPC和RMI有什么区别？ RMI(remote method invocation) 远程方法调用时oop领域中RPC的一种具体实现。 我们熟悉的webservice，restful接口调用是RPC吗？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值