线程池的使用三

已于 2022-11-16 11:03:01 修改
阅读量454 收藏
点赞数
分类专栏： 实操 文章标签： java 数据库
于 2022-10-27 14:59:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/edt777/article/details/127551352
版权

文章目录

  • 前提须知配置类配置线程池
  • 业务场景:A表数据转移到B表. 把A表数据插入到B表,并且把转移的数据在A表设置状态为-1代表已转移了成为无用数据

依赖

<dependency>
			<groupId>com.graphql-java</groupId>
			<artifactId>graphql-java</artifactId>
			<version>19.2</version>
		</dependency>

定时任务跑线程业务(参考)

  • 实际就是一个线程在跑whlie(true){} ,可能不属于规范仅供参考
  • 单纯为了避免线程占用主线程资源,所以把定时任务跑到自定义线程池中执行业务
  • timToQueueJobThreadPool线程池核心数必须设为一个,保证跑完一次业务才进行下一个业务跑,避免数据被重复搜索处理
  • timToQueueThreadPool线程池核心数为5个,因为定时任务内部异步了5个线程保证并发执行,每次搜500条,分别拆100份,则是5条线程异步执行业务
  • 注意:因为用的是oracle,为了避免执行计划缓存过多,所以在业务层遍历执行转移,若是使用mysql数据库,则可以在sql进行遍历插入转移数据
import com.google.common.collect.Lists;
import com.xyc.sms.common.entity.queue.SmsQueueGn;
import com.xyc.sms.syndata.dao.queue.SmsTimingMapper;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;

@Component
@EnableScheduling
@EnableAsync
public class InsertTimingToQueueJob {

    private static final Logger logger = LoggerFactory.getLogger(InsertTimingToQueueJob.class);

    @Qualifier("smsQueueSqlSessionFactory")
    @Resource
    private SqlSessionFactory smsQueueSqlSessionFactory;

    @Autowired
    @Qualifier("timToQueueThreadPool")
    private ThreadPoolExecutor queueThreadPool;



    @Resource
    private SmsTimingMapper smsTimingMapper;

    /**
     * 获取当前时间往后推5分钟的时间,把`队列-定时表`的定时发送时间在该时间之前的都插进原队列表中,并删除自身数据
     * 把队列-定时表的要发送的数据 提前5分钟插入原队列表中
     */

    @Scheduled(fixedDelay = 100)
    @Async("timToQueueJobThreadPool")
    public void insertToQueueByTimingJob() {
        LocalDateTime time = LocalDateTime.now();
        LocalDateTime afterTime = time.plusMinutes(5);
        long selectStartL = System.currentTimeMillis();
        List<SmsQueueGn> smsQueueGnList = smsTimingMapper.getQueueTimingListByAfterTime(afterTime,500);
        long selectEndL = System.currentTimeMillis();
        if (CollectionUtils.isNotEmpty(smsQueueGnList)) {
            long startL = System.currentTimeMillis();
//                量大则分批插入
            CompletableFuture[] allFuture = Lists.partition(smsQueueGnList, 100).stream().map(tempQueues -> {
                return CompletableFuture.runAsync(() -> {
                    long sqlL = System.currentTimeMillis();
                    SqlSession sqlSessionNew = null;
                    try {
                        sqlSessionNew = smsQueueSqlSessionFactory.openSession(ExecutorType.BATCH, false);
                        SmsTimingMapper mapperNew = sqlSessionNew.getMapper(SmsTimingMapper.class);
                        for (int i = 0; i < tempQueues.size(); i++) {
                        //更新A表数据状态为-1
                            mapperNew.updateDataById(tempQueues.get(i).getId());
                        //将搜索出的A表原数据值插入到B表    
                            mapperNew.insertData(tempQueues.get(i));
                        }
                        sqlSessionNew.commit();
                        logger.info("[timToQueueJob] exec sql :{}", System.currentTimeMillis() - sqlL);
                    } catch (Exception e) {
                        Optional.ofNullable(sqlSessionNew).ifPresent(SqlSession::rollback);
                        logger.error("[timToQueueJob]定时任务异步报错:", e);
                    } finally {
                        Optional.ofNullable(sqlSessionNew).ifPresent(SqlSession::close);
                    }

                }, queueThreadPool);
            }).toArray(CompletableFuture[]::new);
            try {
                //等待结果
                CompletableFuture.allOf(allFuture).join();
            } catch (Exception e) {
                logger.error("[timToQueueJob]异步等待插入队列表有误");
            }
            long endL = System.currentTimeMillis();
            logger.info("[timToQueueJob]查询耗时:{},转移耗时:{},本次转移总耗时:{}",selectEndL-selectStartL,endL-startL,endL-selectStartL);
        }


    }


}

线程池配置定义

import com.xyc.sms.common.util.ThreadUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description 转移队列业务线程池配置
 **/
@Configuration
public class QueueThreadPoolConfig {

    private final static Logger logger = LoggerFactory.getLogger(QueueThreadPoolConfig.class);

    @Bean(name = "queueTransferJobConfig")
    public PoolConfig collectReportPoolConfig() {
        return new PoolConfig("QueueTransferJob");
    }

    @Bean(name = "queueTransferSqlConfig")
    public PoolConfig collectMoPoolConfig() {
        return new PoolConfig("QueueTransferSql");
    }

    /**
     * 定时短信转移到队列表
     */
    @Bean(name = "timToQueueThreadPool")
    public ThreadPoolExecutor timToQueueThreadPool(@Qualifier("queueTransferSqlConfig") PoolConfig c) {
        //打印参数日志
        PoolConfig useConfig = c.printInitInfoAndReturnUse();
        return new ThreadPoolExecutor(useConfig.getPoolCoreSize(), useConfig.getPoolMaxSize(), 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(),
                ThreadUtil.threadFactory("timToQueueThreadPool"),
                new ThreadPoolExecutor.CallerRunsPolicy());
    }
    /**
     * 定时短信转移到队列表
     */
    @Bean(name = "timToQueueJobThreadPool")
    public ThreadPoolExecutor timToQueueJobThreadPool(@Qualifier("queueTransferJobConfig") PoolConfig c) {
        //打印参数日志
        PoolConfig useConfig = c.printInitInfoAndReturnUse();
        return new ThreadPoolExecutor(1, 1, 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(),
                ThreadUtil.threadFactory("timToQueueJobThreadPool"),
                new ThreadPoolExecutor.DiscardPolicy());
    }

 


    /**
     * 线程池配置类
     */
    private class PoolConfig {

        private int poolCoreSize = 5;
        private int poolMaxSize = 5;
        private int taskQueueMaxSize = 200;
        private String poolNamPrefix;

        //不配置使用的默认值  ps：如果不配置 yml
        private int poolCoreSize_default = 5;
        private int poolMaxSize_default = 5;
        private int taskQueueMaxSize_default = 200;

        public PoolConfig(String poolNamPrefix) {
            this.poolNamPrefix = poolNamPrefix;
            if (poolNamPrefix.equals("QueueTransferJob")){
                poolCoreSize=1;
                poolMaxSize = 1;
            }
        }

        public int getPoolCoreSize() {
            return poolCoreSize;
        }

        public void setPoolCoreSize(int poolCoreSize) {
            this.poolCoreSize = poolCoreSize;
        }

        public int getPoolMaxSize() {
            return poolMaxSize;
        }

        public void setPoolMaxSize(int poolMaxSize) {
            this.poolMaxSize = poolMaxSize;
        }

        public int getTaskQueueMaxSize() {
            return taskQueueMaxSize;
        }

        public void setTaskQueueMaxSize(int taskQueueMaxSize) {
            this.taskQueueMaxSize = taskQueueMaxSize;
        }

        public String getPoolNamPrefix() {
            return poolNamPrefix;
        }

        public void setPoolNamPrefix(String poolNamPrefix) {
            this.poolNamPrefix = poolNamPrefix;
        }

        public int getPoolCoreSize_default() {
            return poolCoreSize_default;
        }

        public void setPoolCoreSize_default(int poolCoreSize_default) {
            this.poolCoreSize_default = poolCoreSize_default;
        }

        public int getPoolMaxSize_default() {
            return poolMaxSize_default;
        }

        public void setPoolMaxSize_default(int poolMaxSize_default) {
            this.poolMaxSize_default = poolMaxSize_default;
        }

        public int getTaskQueueMaxSize_default() {
            return taskQueueMaxSize_default;
        }

        public void setTaskQueueMaxSize_default(int taskQueueMaxSize_default) {
            this.taskQueueMaxSize_default = taskQueueMaxSize_default;
        }

        private PoolConfig printInitInfoAndReturnUse() {
            PoolConfig us = new PoolConfig(this.poolNamPrefix);
            logger.info(String.format("****************************************%-5s初始化【%-25s】线程池配置项 开始%-5s****************************************", "", us.getPoolNamPrefix(), ""));
            us.setPoolCoreSize(this.poolCoreSize);
            us.setPoolMaxSize(us.getPoolCoreSize());
            us.setTaskQueueMaxSize(Integer.MAX_VALUE);
            logger.info(String.format("**************%-4s 加载 %-25s - %-20s  默认值: %-8d yml配置: %-8d 启动使用配置: %-5d**************",
                    "", us.getPoolNamPrefix(), "poolCoreSize", us.getPoolCoreSize_default(), this.poolCoreSize, us.getPoolCoreSize()));
            logger.info(String.format("**************%-4s 加载 %-25s - %-20s  默认值: %-8d yml配置: %-8d 启动使用配置(使用core配置项): %-5d**************",
                    "", us.getPoolNamPrefix(), "poolMaxSize", us.getPoolMaxSize_default(), this.poolMaxSize, us.getPoolMaxSize()));
            logger.info(String.format("****************************************%-5s初始化【%-25s】线程池配置项 结束%-5s****************************************", "", us.getPoolNamPrefix(), ""));
            return us;
        }

    }

}

线程工具类

import com.google.common.collect.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiFunction;
import java.util.function.Function;


public class ThreadUtil {

    private final static Logger logger = LoggerFactory.getLogger(ThreadUtil.class);

    public static void sleepByWait(long timeout) throws InterruptedException {
        byte[] lock = new byte[0];
        synchronized (lock){
            lock.wait(timeout);
        }
        lock = null;
    }


    public static RejectedExecutionHandler blockExecuteRejectHandle(String name){
        return new BlockExecuteRejectHandle(name);
    }

    public static ThreadFactory threadFactory(String name){
        return new TFactory(name);
    }

    static class TFactory implements ThreadFactory {

        private final ThreadGroup group;
        //编号
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        //池子名称
        private final String namePrefix;

        public TFactory(String name) {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            namePrefix = name.concat("-");
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                    namePrefix + threadNumber.getAndIncrement(),
                    0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }


    static class BlockExecuteRejectHandle implements RejectedExecutionHandler {

        final String name;

        public BlockExecuteRejectHandle(String name) {
            this.name = name.concat("RejectHandle");
        }

        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                try {
                    logger.warn("{} 阻塞加入 | pool:{}",name,e);
                    e.getQueue().put(r);
                } catch (Exception ex) {
                    logger.error("{} 阻塞加入异常",e,ex);
                }
            }
        }
    }

    /**
     * 每个线程任务需要处理的数据量
     * @param dataSize 数据个数
     * @param maxTaskNum 最多创建多少个线程任务
     * @return  返回<=1  就再当前线程执行    返回其他就在池子中执行
     */
    public static int avgCapacity(int dataSize, int maxTaskNum) {
        int _c = dataSize / maxTaskNum;
        if (_c == 0){
            return 0;//dataSize < maxTaskNum 就不使用线程池执行
        }
        return dataSize % maxTaskNum == 0 ? _c : _c + 1;
    }

    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param maxTaskNum 此集合最多拆为几个任务
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResult(ThreadPoolExecutor executor, int maxTaskNum,Function<List<T>, Void> fun,List<T> ls){
        if (ls.isEmpty()){
            return;
        }
        int avgCapacity = ThreadUtil.avgCapacity(ls.size(), maxTaskNum);
        if (avgCapacity <= 1){
            fun.apply(ls);
        }else {
            List<List<T>> lists = Lists.partition(ls, avgCapacity);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp), executor);
            }
            CompletableFuture.allOf(all).join();
        }
    }

    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param oneTaskDataSize 一个任务多少条数据
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResultVo(ThreadPoolExecutor executor, int oneTaskDataSize,Function<List<T>, Void> fun,List<T> ls){
        if (ls.isEmpty()){
            return;
        }
        if (ls.size() <= oneTaskDataSize){
            fun.apply(ls);
        }else {
            List<List<T>> lists = Lists.partition(ls, oneTaskDataSize);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp), executor);
            }
            CompletableFuture.allOf(all).join();
        }
    }


    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param oneTaskDataSize 一个任务多少条数据
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResultVoForAbortPolicyReject(ThreadPoolExecutor executor, int oneTaskDataSize, Function<List<T>, Void> fun, List<T> ls){
        if (ls.isEmpty()){
            return;
        }
        if (ls.size() <= oneTaskDataSize){
            fun.apply(ls);
        }else {
            List<List<T>> lists = Lists.partition(ls, oneTaskDataSize);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                int reNum = 0;
                while (all[i] == null){
                    try {
                        all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp), executor);
                    } catch (RejectedExecutionException e) {
                        if (reNum == 0){
                            logger.warn("线程池处理任务繁忙:{}",e.getMessage());
                        }
                        reNum++;
                        try {Thread.sleep(3);} catch (Exception e1) {}
                    }catch (Exception e){
                        logger.error("线程池处理任务异常",e);
                        break;
                    }
                }

                if (reNum>0){
                    logger.warn("线程池处理任务繁忙 重试次数:{}",reNum);
                }
            }
            CompletableFuture.allOf(all).join();
        }
    }

    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param maxTaskNum 此集合最多拆为几个任务
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResult(ThreadPoolExecutor executor, int maxTaskNum,BiFunction<List<T>, Object, Void> fun, List<T> ls,Object p0){
        if (ls.isEmpty()){
            return;
        }
        int avgCapacity = ThreadUtil.avgCapacity(ls.size(), maxTaskNum);
        if (avgCapacity <= 1){
            fun.apply(ls,p0);
        }else {
            List<List<T>> lists = Lists.partition(ls, avgCapacity);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp,p0), executor);
            }
            CompletableFuture.allOf(all).join();
        }
    }

    /**
     * 某个大集合切割为多个
     * @param ls 数据集
     * @param fun 需要并发执行的方法
     * @param executor 线程池
     * @param maxTaskNum 此集合最多拆为几个任务
     * @param <T>
     */
    public static <T> void concurrentExecuteAndBlockResult(ThreadPoolExecutor executor, int maxTaskNum,BiFunction<List<T>, Object[], Void> fun, List<T> ls,Object... oArr){
        if (ls.isEmpty()){
            return;
        }
        int avgCapacity = ThreadUtil.avgCapacity(ls.size(), maxTaskNum);
        if (avgCapacity <= 1){
            fun.apply(ls,oArr);
        }else {
            List<List<T>> lists = Lists.partition(ls, avgCapacity);
            CompletableFuture[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.runAsync(() -> fun.apply(tmp,oArr), executor);
            }
            CompletableFuture.allOf(all).join();
        }
    }



    public static <T,R> List<R> exec(ThreadPoolExecutor executor, int maxTaskNum,
                                     Function<List<T>, List<R>> fun,
                                     List<T> dataLs){
        if (dataLs.isEmpty()){
            return new ArrayList<>();
        }
        int avgCapacity = avgCapacity(dataLs.size(), maxTaskNum);
        if (avgCapacity <= 1){
            return fun.apply(dataLs);
        }else {
            List<R> ret = new CopyOnWriteArrayList<>();
            List<List<T>> lists = Lists.partition(dataLs, avgCapacity);
            CompletableFuture<? extends List<? extends R>>[] all = new CompletableFuture[lists.size()];
            for (int i = 0; i < lists.size(); i++) {
                List<T> tmp = lists.get(i);
                if (tmp.isEmpty()){
                    continue;
                }
                all[i] = CompletableFuture.supplyAsync(() -> fun.apply(tmp), executor).whenCompleteAsync((rv, ex) -> {
                    if (ex != null) {
                        ex.printStackTrace();
                    }
                    if (rv != null) {
                        ret.addAll(rv);
                    }
                });
            }
            CompletableFuture.allOf(all).join();
            return ret;
        }
    }

}

数据库配置类

  • 注意这里的sqlSessionFactory方法里设置的factoryBean.setTransactionFactory(new JdbcTransactionFactory()); 会导致该项目模块的贴上了事务注解的方法失效报错,谨慎使用,但是贴了以后才能保证 该演示业务数据转移不会因为转移中途关闭程序而丢失数据
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;


@Configuration
@MapperScan(basePackages = { "com.zeki.sms.syndata.dao.queue"}, sqlSessionFactoryRef="smsQueueSqlSessionFactory")
public class SmsQueueDBConfig {

    @Bean(name = "smsQueueDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.hikari.queue-gn")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "smsQueueTransactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("smsQueueDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "smsQueueSqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("smsQueueDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setTransactionFactory(new JdbcTransactionFactory());
        factoryBean.setDataSource(dataSource);
        factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/queue/*.xml"));
        SqlSessionFactory factory = factoryBean.getObject();
//        System.out.println("一级缓存范围: " + factory.getConfiguration().getLocalCacheScope());
//        System.out.println("二级缓存是否被启用: " + factory.getConfiguration().isCacheEnabled());
        factory.getConfiguration().setCacheEnabled(false);
//        System.out.println("二级缓存是否被启用: " + factory.getConfiguration().isCacheEnabled());
        return factory;
//        return factoryBean.getObject();
    }


}

yml配置数据库连接参数

  • oracle数据库连接参数,仅供参考
spring:
  datasource:
    hikari:
      queue-gn:
        driver-class-name: oracle.jdbc.OracleDriver
        jdbc-url: jdbc:oracle:thin:@192.168.3.212:1521:zekidb
        username: SMS_QUEUE_DEV
        password: SMS_QUEUE_DEV
        type: com.alibaba.druid.pool.DruidDataSource
        filters: stat
        max-wait: 60000
        initial-size: 10
        maxActive: 20
        minIdle: 10
        #间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
        timeBetweenEvictionRunsMillis: 60000
        #minEvictableIdleTimeMillis 一个连接在池中最小空闲的时间，单位是毫秒
        minEvictableIdleTimeMillis: 300000
        #检测连接是否可用的 SQL
        validationQuery: SELECT 'z'
        #是否开启空闲连接检查
        testWhileIdle: true
        #是否在获取连接前检查连接状态
        testOnBorrow: false
        #是否在归还连接时检查连接状态
        testOnReturn: false
zeki豪
关注
专栏目录
MyBatis源码面试题
波波烤鸭的博客
03-29 2193
MyBatis源码面试题
浅谈Sqlsession和数据库的连接池
mostlove
03-31 1万+
之前mybatis关于Sqlsession的事务的提交，有很多的不解，通过这两天的努力，大致了解了下，分享下，也顺便总结下： 其实我们早就应该知道，在使用mybatis的时候，事务提交的时候，每次，我们都会调用SqlSession来进行事务的提交，提交完成后，也进行了手动的关闭操作；不难理解，这个似乎和JDBC在操作数据的时候，大家经常写的 BaseDao一样，也就是，在操作JDBC的时
MyBatis（八）如何构建一个线程安全的SqlSession
新新许愿树
09-08 6991
利用ThreadLocal获取或者关闭SqlSession对象，实现每一个线程都有自己的一个SqlSession对象。 TheadLocal 线程局部变量 ThreadLocal 的作用和目的：用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。 每个线程调...
MyBATIS原理第三篇: SqlSession下的四大对象之一——执行器（executor）
ykzhen2015的专栏
12-15 1万+
首先我先解释一下标题 四大对象是指：executor, statementHandler,parameterHandler，resultHandler对象。（为了方便下面的文章说道四大对象就专指它们） 它们都是sqlSession的底层类实现，也是插件能够拦截的四大对象。所以这里已经触及了MyBATIS的底层，动态代理，反射随时可以看到，如果没有第一篇作为基础，你将十分难以理解它。了解他们的协作
SqlSessionTemplate是如何保证MyBatis中SqlSession的线程安全的？
热门推荐
徐刘根的博客
03-04 2万+
一、DefaultSqlSession的线程不安全性 在MyBatis架构中SqlSession是提供给外层调用的顶层接口，实现类有：DefaultSqlSession、SqlSessionManager以及mybatis-spring提供的实现SqlSessionTemplate。默认的实现类为DefaultSqlSession如。类图结构如下所示： 对于MyBatis提供的原生实现类来...
python 线程池使用
小胖_@的博客
08-05 7850
当线程池初始化时，会自动创建指定数量的线程，有任务到达时直接从线程池中取一个空闲线程来用即可，当任务执行结束时线程不会消亡而是直接进入空闲状态，继续等待下一个任务。而随着任务的增加线程池中的可用线程必将逐渐减少，当减少至零时，任务就需要等待了。在 python 中使用线程池有两种方式：一、是基于第三方库 threadpool二、是基于 python3 新引入的库 concurrent.futures.ThreadPoolExecutor。......
C# 线程池使用示例
12-04
3. ThreadPool.SetMaxThreads / ThreadPool.SetMinThreads：设置线程池的最大和最小线程数，需谨慎使用，以免影响系统性能。 线程池的优势： 1. 资源优化：线程池避免了频繁创建和销毁线程的开销，节省了系统资源。...
线程池使用Demo
05-06
线程池是Java并发编程中的重要概念，它是一种线程使用模式，用于高效地管理和执行大量并发任务。在Java中，我们主要通过`java.util.concurrent`包中的`ExecutorService`接口及其实现类来创建和管理线程池。线程池的...
Java线程池使用说明
02-24
3. 提交任务：将任务提交给线程池执行，线程池会根据线程池的配置和当前的线程状况，决定如何处理这些任务。 4. 关闭线程池：完成任务后，应该关闭线程池，释放相关资源。 在实现过程中，对于线程池的合理配置非常...
VB线程池使用
11-12
VB 线程池使用 VB 线程池使用是多线程应用程序中的一种重要概念，它可以有效地改善应用程序的响应时间，减少系统资源的占用，提高系统的性能。在多线程应用程序中，线程池的使用可以解决线程生命周期的开销问题和...
详谈Java几种线程池类型介绍及使用方法
08-31
一、线程池使用场景 线程池的使用场景有很多，例如： * 单个任务处理时间短 * 将需处理的任务数量大 二、使用 Java 线程池的好处 使用 Java 线程池可以带来以下好处： * 重用存在的线程，减少对象创建、消亡的...
线程池的大坑啊
随手记两笔
09-18 575
任务队列BlockingQueue     排队原则 　　1. 如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。 　　2. 如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。 　　3. 如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolS
记一个session和线程池问题，待解决
qq_38443949的博客
08-13 484
不同用户在不同的pc或浏览器登陆网页应用，项目部署在一台服务器上，项目是如何在session中取出对应的userId(假定登录的时候将userId存入了session)?
SqlSessionTemplate是如何保证的MyBatis中的SqlSession的线程安全的？
huangshulang1234的博客
04-01 1994
SqlSessionTemplate是如何保证的MyBatis中的SqlSession的线程安全的？ 一，DefaultSqlSession的线程不安全性 在MyBatis的架构中的SqlSession是提供给外层调用的顶层接口，实现类有：DefaultSqlSession，SqlSessionManager以及MyBatis的弹簧提供的实现SqlSessionTemplate
spring循环依赖解决方式
qq_36400213的博客
11-04 889
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JAVA-01-变量
LJH_laura_li的博客
11-08 158
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 38
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
JAVA学习接口案例实例
最新发布
shangan_3的博客
11-08 98
【代码】JAVA学习接口案例实例。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 417
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
ThreadPoolTaskExecutor线程池使用
03-08
3. 提交任务：通过调用ThreadPoolTaskExecutor的execute()方法或submit()方法，将需要执行的任务提交给线程池。 4. 控制任务执行：可以通过设置线程池的相关属性来控制任务的执行，如设置核心线程数、最大线程数、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值