mysql线程池

本文介绍了如何通过依赖mysql-connector-java库配置db.properties文件,展示如何在Java中加载配置并建立Connection对象,同时探讨了使用MysqlConnectionPool实现数据库连接池管理。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

mysql依赖

   <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>

配置文件 db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://192.168.232.211:3306/school
user = root
password=ok
public class FinalFields {
    public static final String MYSQL_DRIVER_STR="driver";
    public static final String MYSQL_USER_STR="user";
    public static final String MYSQL_URL_STR="url";
    public static final String MYSQL_PWD_STR="password";
}

加载配置文件

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class PropUtils {
    public static Properties getProperties(String profileName) throws IOException {
        //加载resource文件里的db.properties
        ClassLoader classLoader = PropUtils.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream(profileName);
        Properties props = new Properties();
        props.load(is);
        return props;
    }
}

建立Connection对象

import java.io.IOException;
import java.sql.*;
import java.util.Properties;

/**
 * 获取数据库连接对象 Connection
 */
public class Mysql {
    private static String driver;
    private static String url;
    private static String user;
    private static String password;
    static {
        Properties props = null;
        try {
            props = PropUtils.getProperties("db.properties");
        } catch (IOException e) {
            e.printStackTrace();
        }
        driver=props.getProperty(FinalFields.MYSQL_DRIVER_STR);
        url=props.getProperty(FinalFields.MYSQL_URL_STR);
        user=props.getProperty(FinalFields.MYSQL_USER_STR);
        password=props.getProperty(FinalFields.MYSQL_PWD_STR);
    }

    public static Connection getConnection(){
        System.out.println(driver);
        Connection connection = null;
        try {
            Class.forName(driver);//加载驱动
            connection = DriverManager.getConnection(url, user, password);
        } catch (SQLException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return connection;
    }
    //释放资源
    public static void close(Connection conn, PreparedStatement psmt, ResultSet rs){
        if (rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (psmt!=null) {
            try {
                psmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn!=null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Connection connection = Mysql.getConnection();
        System.out.println(connection);
        Mysql.close(connection,null,null);
    }
}

package nj.zb.kb11;

import java.sql.Connection;
import java.util.LinkedList;


public class MysqlConnectionPool {
    private Integer initNum = 5; //初始化时Connection的数量
    private Integer increase = 5; // 每次获取Connection对象的数量
    private Integer min = 3;      // 允许连接池中拥有Connection对象的最小数量
    private Integer max = 20;     //  允许连接池中拥有Connection对象的最大数量

    private Byte b = 1;   // 同步锁
    private boolean xiaoguogo = false;  // false 小谷在家  true 小谷出去取Connection对象去了


    // 用于存放Connection对象
    private LinkedList<Connection> pool = new LinkedList<>();

    private void produceConnection(Integer num) {
        for (int i = 0; i < num; i++) {
            if(!checkPoolMaxNum()){
                xiaoguogo = false;
                pool.add(JDBCUtils.getConnection());
            }
        }
    }

    private boolean checkPoolMaxNum() {
        if (pool.size() > max) {
            return true;
        } else {
            return false;
        }
    }

    private MysqlConnectionPool() {
        produceConnection(initNum);
    }

    /**
     * 查询连接池Connection对象的数量
     *
     * @return
     */
    public Integer count() {
        return pool.size();
    }


    public Connection getConnection() {
//        pool.get(0);
//        pool.getFirst();
        synchronized (b) {
            while (pool.size() == 0) {
                System.out.println("warning, 连接池没有连接。。。。。。");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (pool.size() <= min && !xiaoguogo) {   // 3
                xiaoguogo = true;
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        produceConnection(increase);
                    }
                }).start();
            }
            return pool.pop();
        }
    }

    public void close(Connection conn) {
        synchronized (b) {
            if (conn == null) {
                return;
            } else {
                if (checkPoolMaxNum()) {
                    JDBCUtils.close(conn);
                } else {
                    pool.add(conn);
                }
            }
        }
    }


//   懒汉模式
//    private static MysqlConnectionPool poolInstance=null;
//    public static MysqlConnectionPool getPoolInstance(){
//        if(poolInstance==null){
//            poolInstance = new MysqlConnectionPool();
//        }
//        return poolInstance;
//    }

    //  饿汉模式
    private static MysqlConnectionPool poolInstance2 = new MysqlConnectionPool();

    public static MysqlConnectionPool getPoolInstance() {
        return poolInstance2;
    }


}

MySQL线程池连接时间是指**在MySQL中,每个连接使用一个单独的线程来处理客户端发来的请求。当有大量并发连接时,为了改善性能下降的问题,MySQL引入了线程池的概念**。线程池由一定数量的线程组构成,每个线程组管理一组客户端连接,最大连接数为4096。连接创建之后会以轮询的方式分配给线程组。 关于MySQL线程池的具体配置和使用,以下是一些关键点: 1. **线程池大小**:可以通过`thread_pool_size`系统变量来配置线程池的大小。默认情况下,MySQL会根据系统的资源情况自动调整线程池的大小,但用户也可以根据需要手动设置。 2. **连接等待时间**:应用程序从连接池中获取连接的最大等待时间通常由连接池的配置决定,例如Druid连接池中的`maxWait`参数。这个时间可以根据实际情况进行调整,以避免长时间等待导致的超时错误。 3. **连接验证**:为了确保连接池中的连接是有效的,可以在获取连接时进行验证。例如,在Druid连接池中,可以配置`testOnBorrow`、`testWhileIdle`和`validationQuery`等参数来实现连接验证。 4. **连接保持活跃**:为了避免Linux系统主动断开长时间没有通信的连接,可以在连接池配置中加入相关设置,如HikariCP中的`spring.datasource.testOnBorrow=true`和`spring.datasource.validationQuery=SELECT 1`。 综上所述,MySQL线程池连接时间涉及多个方面,包括线程池的大小、连接等待时间、连接验证以及连接保持活跃等。这些配置可以根据具体的应用场景和需求进行调整,以优化数据库的性能和稳定性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值