pgsql计算两个日期时间差&&自定义线程池的创建使用
select round(cast(date_part('epoch',to_timestamp((to_timestamp('2023-02-11 10:00:00','yyyy-mm-dd hh24:MI:SS')+ interval'1 day')::text,'yyyy-mm-dd hh24:MI:SS')
- to_timestamp((now() + interval '8 hour')::text,'yyyy-mm-dd hh24:MI:SS'))/60/60/24 as numeric),2)
as timeremaining ;
select round(cast(date_part('epoch',to_timestamp((start_time + interval'1 day')::text,'yyyy-mm-dd hh24:MI:SS')
- to_timestamp((now() + interval '8 hour')::text,'yyyy-mm-dd hh24:MI:SS'))/60/60/24 as numeric),3)
as timeremaining from company;
select round(cast(date_part('epoch',to_timestamp('2023:05:20 00:00:00'::text,'yyyy-mm-dd hh24:MI:SS')
-to_timestamp((now()+interval '8 hour')::text,'yyyy-mm-dd hh24:MI:SS'))/60/60/24 as numeric),2)
方式一：
application.yml
#线程池配置参数
task:
pool:
corePoolSize: 5 #设置核心线程数
maxPoolSize: 20 #设置最大线程数
keepAliveSeconds: 300 #设置线程活跃时间（秒）
queueCapacity: 50 #设置队列容量
启动类上加上开启线程池注解
@SpringBootApplication
@EnableAsync
@EnableConfigurationProperties({TaskThreadPoolConfig.class} ) // 开启配置属性支持
public class ThreadPoolApplication {
public static void main(String[] args) {
SpringApplication.run(ThreadPoolApplication.class, args);
}
}
线程池配置属性类TaskThreadPoolConfig .java
package com.threadpool.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* 线程池配置属性类
*/
@ConfigurationProperties(prefix = "task.pool")
@Data
public class TaskThreadPoolConfig {
private int corePoolSize;
private int maxPoolSize;
private int keepAliveSeconds;
private int queueCapacity;
}
创建线程池 TaskExecutePool .java
package com.threadpool.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 创建线程池配置类
*/
@Configuration
public class TaskExecutePool {
@Autowired
private TaskThreadPoolConfig config;
/**
* 1.这种形式的线程池配置是需要在使用的方法上面@Async("taskExecutor"),
* 2.如果在使用的方法上面不加该注解那么spring就会使用默认的线程池
* 3.所以如果加@Async注解但是不指定使用的线程池，又想自己定义线程池那么就可以重写spring默认的线程池
* 4.所以第二个方法就是重写默认线程池
* 注意：完全可以把线程池的参数写到配置文件中
*/
@Bean("mytask")
public Executor taskExecutor() {
System.out.println("mymymymm");
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
//核心线程池大小
executor.setCorePoolSize(config.getCorePoolSize());
//最大线程数
executor.setMaxPoolSize(config.getMaxPoolSize());
//队列容量
executor.setQueueCapacity(config.getQueueCapacity());
//活跃时间
executor.setKeepAliveSeconds(config.getKeepAliveSeconds());
//线程名字前缀
executor.setThreadNamePrefix("TaskExecutePool-");
// setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务
// CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 等待所有任务结束后再关闭线程池
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.initialize();
return executor;
}
}
在方法上添加@Async注解（可以指定线程池名字）
@GetMapping("/test2")
@ResponseBody
@Async("mytask")
public String findAllData2() throws ExecutionException, InterruptedException {
}
方式二：
package com.threadpool.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.ThreadPoolExecutor;
@EnableAsync
@Configuration
public class ThreadPoolConfig {
/**
* 默认的线程池名称为myPoolExecutor
* 可以通过@Bean("name")方式进行指定
*/
@Bean
public TaskExecutor myPoolExecutor() {
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
// 核心线程数
taskExecutor.setCorePoolSize(6);
// 最大线程数
taskExecutor.setMaxPoolSize(10);
// 线程空间等待时间（秒）
taskExecutor.setKeepAliveSeconds(60);
// 任务队列大小
taskExecutor.setQueueCapacity(100);
// 线程前缀
taskExecutor.setThreadNamePrefix("my-thread");
// 拒绝策略
taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 等待所有任务结束后关闭线程池
taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
return taskExecutor;
}
}
//# 异步调用配置
//asyncThreadPool:
// # 核心线程数
// corePoolSize: 10
// # 最大线程数
// maxPoolSize: 20
// # 任务队列大小
// queueCapacity: 2
// # 缓冲队列中线程的空闲时间
// keepAliveSeconds: 60
// # 线程池中线程的名称前缀
// threadNamePrefix: asyncServiceExecutor-
///**
// * 线程池参数配置，多个线程池实现线程池隔离，@Async注解，默认使用系统自定义线程池，可在项目中设置多个线程池，在异步调用的时候，指明需要调用的线程池名称，比如：@Async("taskName")
// * @author dzh
// */
//@Configuration
//@Slf4j
//public class TaskPoolConfig {
//
// @Value("${asyncThreadPool.corePoolSize}")
// private int corePoolSize;
//
// @Value("${asyncThreadPool.maxPoolSize}")
// private int maxPoolSize;
//
// @Value("${asyncThreadPool.queueCapacity}")
// private int queueCapacity;
//
// @Value("${asyncThreadPool.keepAliveSeconds}")
// private int keepAliveSeconds;
//
// @Value("${asyncThreadPool.threadNamePrefix}")
// private String threadNamePrefix;
//
// @Bean("asyncExecutor")
// public Executor taskExecutor() {
//
// log.info("启动自定义线程池");
// ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
// //核心线程池大小
// executor.setCorePoolSize(corePoolSize);
// //最大线程数
// executor.setMaxPoolSize(maxPoolSize);
// //配置队列容量
// executor.setQueueCapacity(queueCapacity);
// //活跃时间
// executor.setKeepAliveSeconds(keepAliveSeconds);
// //线程名字前缀
// executor.setThreadNamePrefix(threadNamePrefix);
// // 拒绝策略
// executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// // 线程初始化
// executor.initialize();
// return executor;
// }
@GetMapping("/test3")
@ResponseBody
@Async("myPoolExecutor")
public String findAllData3() throws ExecutionException, InterruptedException {
}