定时取消的时间事件
?
1、定时任务
/**
- 定时任务
- 优点:简单易行,支持集群操作
- 缺点:(1)对服务器内存消耗大
- (2)存在延迟,比如你每隔3分钟扫描一次,那最坏的延迟时间就是3分钟
- (3)数据量大,每隔几分钟这样扫描一次,数据库损耗极大
public class MyJob implements Job {
public void execute(JobExecutionContext jobExecutionContext)
throws JobExecutionException {
System.out.println("进入数据库");
}
public static void main(String[] args) throws SchedulerException {
// 创建任务
JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
.withIdentity("job1","group1").build();
// 创建触发器Trigger 每三秒执行一次
Trigger trigger= TriggerBuilder
.newTrigger()
.withIdentity("trigger1", "group3")
.withSchedule(
SimpleScheduleBuilder
.simpleSchedule()
.withIntervalInSeconds(3)
.repeatForever()
) .build();
/**
- 创建和初始化Quartz Scheduler调度工厂
- 调用工厂中的getScheduler()将生成调度程序
Scheduler scheduler = new StdSchedulerFactory().getScheduler();
// 将任务及其触发器放入调度器
scheduler.scheduleJob(jobDetail,trigger);
// 调度器开始调度任务
scheduler.start();
}
}
2、延迟队列
/**
- 延迟队列
- JDK自带的DelayQueue来实现,
- 这是一个无界阻塞队列,
- 该队列只有在延迟期满的时候才能从中获取元素,
- 放入DelayQueue中的对象,是必须实现Delayed接口的。
- 优点:效率高,任务触发时间延迟低。
- 缺点:
- (1)服务器重启后,数据全部消失,怕宕机
- (2)集群扩展相当麻烦
- (3)因为内存条件限制的原因,比如下单未付款的订单数太多,那么很容易就出现OOM异常
- (4)代码复杂度较高
public class OrderDelay implements Delayed {
private String orderId;
private Long timeout;
OrderDelay(String orderId, Long timeout) {
this.orderId = orderId;
this.timeout = timeout + System.nanoTime();
}
/**
- 用于延迟队列内部的比较排序 当前时间的延迟时间-比较对象的延迟时间
- @param other
- @return
public int compareTo(Delayed other) {
if(other == this) {
return 0;
}
OrderDelay t = (OrderDelay) other;
Long d = (getDelay(TimeUnit.NANOSECONDS) - t
.getDelay(TimeUnit.NANOSECONDS));
return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
}
/**
- 返回距离你自定义的超时时间还有多久
- 获得延迟时间 过期时间-当前时间
- @param unit
- @return
public long getDelay(TimeUnit unit) {
return unit.convert(
timeout - System.nanoTime(),
TimeUnit.NANOSECONDS);
}
void print() {
System.out.println(orderId + "开始启动了");
}
}
3、时间轮算法
package wheeltime;
import io.netty.util.*;
import io.netty.util.TimerTask;
import java.util.concurrent.*;
/**
- Netty的HashedWheelTimer来实现
- 优点:效率高,任务触发时间延迟时间比delayQueue低,代码复杂度比delayQueue低。
- 缺点:
- (1)服务器重启后,数据全部消失,怕宕机
- (2)集群扩展相当麻烦
- (3)因为内存条件限制的原因,比如下单未付款的订单数太多,那么很容易就出现OOM异常
*/
static class MyTimerTask implements TimerTask {
boolean flag;
public MyTimerTask(boolean flag) {
this.flag = flag;
}public void run(Timeout timeout) throws Exception {
System.out.println("要去删除了。。。");
this.flag = false;
}
}public static void main(String[] argv) {
MyTimerTask timerTask = new MyTimerTask(true);
Timer timer = new HashedWheelTimer();
//轮数,时间,时间单位
timer.newTimeout(timerTask, 5, TimeUnit.SECONDS);
int i = 1;
while(timerTask.flag) {
try {
Thread.sleep(1000);
} catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println(i + "过去了");
i++;
}
}
}
4、Redis缓存
方式一:
利用redis的zset,zset是一个有序集合,每一个元素(member)都关联了一个score,通过score排序来取集合中的值
利用redis命令理解思路
添加单个元素
redis> ZADD page_rank 10 google.com
(integer) 1
添加多个元素
redis> ZADD page_rank 9 baidu.com 8 bing.com
(integer) 2
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
查询元素的score值
redis> ZSCORE page_rank bing.com
"8"
移除单个元素
redis> ZREM page_rank google.com
(integer) 1
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
java实现:
package timestop.redisout;
import redis.clients.jedis.*;
import java.util.*;
/**
- 利用redis缓存
- 缺点:高并发条件下,多消费者会取到同一个订单号
- 改进:
- (1)用分布式锁,但是用分布式锁,性能下降了,该方案不细说。
- (2)对ZREM的返回值进行判断,只有大于0的时候,才消费数据,于是将consumerDelayMessage()方法里的
*/
private static final String ADDR = "127.0.0.1";
private static final int PORT = 6379;
//JedisPool创建线程安全的网络连接池
private static JedisPool JedisPool = new JedisPool(ADDR, PORT);
//获取连接池的一个jedis对象
public static Jedis getJedis() {
return JedisPool.getResource();
}//生产者, 生成5个订单放进去
public void productionDelayMessage() {
for(int i = 0;
i < 5;
i++) {/**
*设置时间延迟3秒
*Calendar.getInstance()
*取一个Calendar对象并可以进行时间的计算,时区的指定
*/
Calendar cal1 = Calendar.getInstance();
//Calendar.SECOND时间单位,amount时间数
cal1.add(Calendar.SECOND, 3);
//cal1.getTimeInMillis()用于返回此日历的当前时间 (以毫秒为单位)。
int second3later = (int) (cal1.getTimeInMillis() / 1000);
//getJedis().zadd添加元素
AppTest.getJedis().zadd("OrderId", second3later, "OID0000001" + i);
System.out.println(System.currentTimeMillis() + "ms:redis生成了一个订单任务:订单ID为\"+\"OID0000001" + i);
}
}//消费者, 取订单
public void consumerDelayMessage() {
Jedis jedis = AppTest.getJedis();
while(true) {
//返回有序集合中指定分数区间的成员列表。
Set items = jedis.zrangeWithScores("OrderId", 0, 1);
if(items == null || items.isEmpty()) {
System.out.println("当前没有等待的任务");
try {
Thread.sleep(500);
} catch(InterruptedException e) {
e.printStackTrace();
}
continue;
}
int score = (int) ((Tuple) items.toArray()[0]).getScore();
/**
* Calendar.getInstance()
* 取一个Calendar对象并可以进行时间的计算,时区的指定
*/
Calendar cal = Calendar.getInstance();
//cal1.getTimeInMillis()用于返回此日历的当前时间 (以毫秒为单位)。
int nowSecond = (int) (cal.getTimeInMillis() / 1000);
//原版 有多个线程消费同一个资源的情况
//if(nowSecond >= score) {
//String orderId = ((Tuple) items.toArray()[0]).getElement();
//jedis.zrem("OrderId", orderId);
//System.out.println(System.currentTimeMillis() + "ms:redis消费了一个任务:消费的订单OrderId为" + orderId);
//}//改进后
if(nowSecond >= score) {
String orderId = ((Tuple) items.toArray()[0]).getElement();
Long num = jedis.zrem("OrderId", orderId);
if(num != null && num > 0) {
System.out.println(System.currentTimeMillis() + "ms:redis消费了一个任务:消费的订单OrderId为" + orderId);
}
}
}
}public static void main(String[] args) {
AppTest appTest = new AppTest();
appTest.productionDelayMessage();
appTest.consumerDelayMessage();
}
}
方式二:
该方案使用redis的Keyspace Notifications,中文翻译就是键空间机制,就是利用该机制可以在key失效之后,提供一个回调,实际上是redis会给客户端发送一个消息。是需要redis版本2.8以上。 实现二 在redis.conf中,加入一条配置 notify-keyspace-events Ex
public class RedisTest {
private static final String ADDR = "127.0.0.1";
private static final int PORT = 6379;
private static JedisPool jedis = new JedisPool(ADDR, PORT);
private static RedisSub sub = new RedisSub();
public static void init() {new Thread(new Runnable() {public void run() {jedis.getResource().subscribe(sub, "__keyevent@0__:expired");
}}).start();
}public static void main(String[] args) throws InterruptedException {init();
for(int i =0;
i<10;
i++){String orderId = "OID000000"+i;
jedis.getResource().setex(orderId, 3, orderId);
System.out.println(System.currentTimeMillis()+"ms:"+orderId+"订单生成");
}}static class RedisSub extends JedisPubSub {@Overridepublic void onMessage(String channel, String message) {System.out.println(System.currentTimeMillis()+"ms:"+message+"订单取消");
}}
【定时取消的时间事件】}
?
推荐阅读
- 消息复杂计算的抽象和简化
- 网络标准之:IANA定义的传输编码
- LeetCode|LeetCode 42. Trapping Rain Water-五秒内就能理解的O(n)思路
- Map集合遍历的两种方式
- NextRPC : RPC多段返回的创新和探索
- react 16.8版本新特性以及对react开发的影响
- 最通俗易懂的原型、原型链理解
- 微软|狠! 在GitHub 上 Star 高达 72K 的项目 Youtube-dl 惨遭官方下架!
- Google V8系列(三)V8提升函数执行效率的策略(Inline Cache(内联缓存))
- 常用数组方法