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

最新推荐文章于 2022-10-16 20:46:31 发布
最新推荐文章于 2022-10-16 20:46:31 发布
阅读量165 收藏 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
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MP3-MP6播放器探秘（3）
01-20
高清MP4和普通MP4都是属于掌上型多媒体数字播放设备，高清MP4只是普通MP4的升级产品，两者的主要功能是相同的，高清MP4被提升的主要性能为清晰度指标，以满足那些讲求视觉享受的发烧友和用户的需求。 　1.高清MP4...
Java GenericObjectPool 对象池化技术--SpringBoot sftp 连接池工具类
20年码农
04-07 2170
通常一个对象创建、销毁非常耗时的时候，我们不会频繁的创建和销毁它，而是考虑复用。复用对象的一种做法就是对象池，将创建好的对象放入池中维护起来，下次再用的时候直接拿池中已经创建好的对象继续用，这就是池化的思想。Apache Commons Pool是一个对象池的框架，他提供了一整套用于实现对象池化的API。
SpringBoot整合common-pool2实现对象池
爱码猿的博客
10-16 2932
使用池化主要是为了节省对象创建和销毁的开销。比如日常开发息息相关的数据源连接池，就是为了减少连接创建的时间而生的。commons-pool是apacha基金会开源的一款常见的对象池工具库。springBoot整合common-pool实现对象池。
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
资源池以及资源池化是什么意思？
行云管家
07-22 6739
资源池是什么意思？资源池化是什么意思？相信有很多刚入行的运维人员不是很了解，下面我们就一起看看。
计算资源池化
热门推荐
布衣之旅
07-29 1万+
计算资源池化
MP3-MP6播放器探秘（2）
01-20
二、MP4播放器 　前文进过，MP3播放器是一种主要对MP3等音乐文件进行存储、解码和播放的微小型数字音频设备。那么MP4是什么？简单的说，MP4播放器就是“随身看”，与MP3播放器是“随身听”相互对应。...
入门深度学习--探秘lstm
01-06
一次部门内部分享的PPT
基础电子中的MP3-MP6播放器探秘（2）
10-22
二、MP4播放器 　前文进过，MP3播放器是一种主要对MP3等音乐文件进行存储、解码和播放的微小型数字音频设备。那么MP4是什么？简单的说，MP4播放器就是“随身看”，与MP3播放器是“随身听”相互对应。...
java中的线程并发库-----javaconcurrent探秘
01-31
而当针对高质量Java多线程并发程序设计时,为防止死蹦等现象的出现，比如使用java之前的wait()、notify()和synchronized等，每每需要考虑性能、死锁、公平性、资源管理以及如何避免线程安全性方面带来的危害等诸多...
Java 高性能队列底层到底是什么？
GitChat
07-29 606
本 Chat 解析市面上常见的 Java 优秀队列中的底层存储技术细节。 通过本 Chat ，你可以学习到： 我司自研队列的底层高速存储细节 RocketMQ 底层存储细节 Kafka 底层存储细节 我们都知道 Kafka，RocketMQ 速度快，那么到底为什么块，细节是什么，大部分文章都不会去关注，本 Chat 不讲概念，让你实实在在看到实现细节的分析和代码。...
[深度学习] 池化层函数及其逆过程函数
真理无穷，进一步有进一步的欢喜
06-27 1299
class torch.nn.MaxPool1d() class torch.nn.MaxPool2d() class torch.nn.MaxPool3d() class torch.nn.AvgPool1d() class torch.nn.AvgPool3d() class torch.nn.AvgPool3d()
基于Redis生成递增序号
G0_hw
07-31 4170
一. 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 574
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 448
注解+反射实现动态调用
G0_hw
07-30 359
一. 业务场景说明     微服务开发，有两个独立的应用服务：a 和 b，a是聚合入口服务，单向调用关系，即 a -> b。又有一个开放平台服务c，需要先调用a，然后再a中回调通知b。但开发平台回调通知的时间有很多，在a中不想对每一个通知时间都写一个方法rest接口来接收，而是想用一个rest方法统一收归开放平台的各种通知，然后根据通知类型分派到b中不同的api里，这样保证了a作为聚合入口服务的纯粹性，开放平台也只需要和a的这一个统一收归的接口交互，真正的业务处
分布式锁应用与实践
G0_hw
01-13 279
一.为什么需要分布式锁 场景描述：小型电商网站，下单，生产有一定业务含义的唯一订单编号 如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 253
一. RPC是什么？ remote procedure call,远程过程调用。其中远程表示不同应用间的调用，过程就是业务处理，计算任务，更直白理解，就是程序(像调用本地方法一样调用远程的过程)。 RPC采用Client-Server结构，通过request-response消息模式实现。 RPC和RMI有什么区别？ RMI(remote method invocation) 远程方法调用时oop领域中RPC的一种具体实现。 我们熟悉的webservice，restful接口调用是RPC吗？
探秘System.Threading序列 - 第一篇：从Thread的线程单元状态ApartmentState说起
最新发布
06-07
好的，让我来回答你的问题。你想了解System.Threading序列的第一篇文章，它从Thread的线程单元状态ApartmentState说起。 Thread类在.NET Framework中是一个非常重要的类，它提供了一种在程序中创建和管理线程的方式。在使用Thread类之前，我们需要了解线程单元状态（ApartmentState）。线程单元状态是指一个线程所在的单元，它决定了线程在运行时的行为。 在.NET Framework中，线程单元状态有两种：Single Threaded Apartment和Multi-Threaded Apartment。Single Threaded Apartment是指只有一个线程可以进入该单元，它适用于单线程的应用程序。Multi-Threaded Apartment是指多个线程可以进入该单元，它适用于多线程的应用程序。 在Thread类中，我们可以使用ApartmentState属性来设置线程单元状态。默认情况下，线程单元状态是Multi-Threaded Apartment。如果我们想将线程单元状态设置为Single Threaded Apartment，可以使用以下代码： ```csharp Thread t = new Thread(new ThreadStart(TestMethod)); t.SetApartmentState(ApartmentState.STA); t.Start(); ``` 在以上代码中，我们创建了一个新的线程，并将线程单元状态设置为Single Threaded Apartment。然后，我们启动线程并开始执行TestMethod方法。 总之，了解线程单元状态对于使用Thread类来创建和管理线程是非常重要的。在下一篇文章中，我们将继续探讨System.Threading序列的内容。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值