java延时sleep Java延时判断

• 业务场景：
• 1.数据库轮询

• 1.1 思路
• 1.2 实现

• 1.2.1在启动类上添加注解@EnableScheduling，如下图所示：
• 1.2.2 创建配置类，添加注解@Scheduled

• 1.3 优缺点

• 2.JDK的延迟队列

• 2.1 思路
• 2.2 实现
• 2.3 优缺点

• 3.时间轮算法

• 3.1 思路
• 3.2 实现

• 3.2.1 添加maven依赖
• 3.2.2 具体实现

• 3.3 优缺点

• 4.redis缓存

• 4.1 利用redis的zset

• 4.1.1 添加redis依赖
• 4.1.2 解决多线程消费同一资源

• 4.2 使用redis的Keyspace Notifications（键空间机制）
• 4.3 优缺点

• 5.使用消息队列

• 5.1 思路
• 5.2 实现
• 5.3 优缺点

业务场景：

1.生成订单30分钟未支付，则自动取消，我们该怎么实现呢？
2.生成订单60秒后,给用户发短信

对上述的两个业务场景，我们给一个专业的名字来形容，那就是延时任务。那么这里就会产生一个问题，这个延时任务和定时任务的区别究竟在哪里呢？一共有如下几点区别:

• 定时任务有明确的触发时间，延时任务没有
• 定时任务有执行周期，而延时任务在某事件触发后一段时间内执行，没有执行周期
• 定时任务一般执行的是批处理操作是多个任务，而延时任务一般是单个任务

下面我们通过判断订单是否超时为例，进行方案分析

1.数据库轮询

1.1 思路

该方案通常是在小型项目中使用，即通过一个线程定时的去扫描数据库，通过订单时间来判断是否有超时的订单，然后进行update或delete等操作

1.2 实现

通过springBoot中的@Schedule进行实现

1.2.1在启动类上添加注解@EnableScheduling，如下图所示：

1.2.2 创建配置类，添加注解@Scheduled

@Controller
public class UpdateTimeSchedule {
   @Scheduled(fixedDelay = 1000 * 10)
    public void work() {
  // do your work here
  
}

}

上例每隔10秒执行一次，设第一次执行开始时时间为 0，如果任务的执行时间是 5 秒，那下次任务的开始时间是 5 + 10 = 15 即第 15 秒。再下一次任务开始执行时间是 15 + 5 + 10 = 30 即第 30 秒，以此类推

1.3 优缺点

优点:简单易行，支持集群操作
缺点:(1)对服务器内存消耗大
(2)存在延迟，比如你每隔3分钟扫描一次，那最坏的延迟时间就是3分钟
(3)假设你的订单有几千万条，每隔几分钟这样扫描一次，数据库损耗极大

2.JDK的延迟队列

2.1 思路

该方案是利用JDK自带的DelayQueue来实现，这是一个无界阻塞队列，该队列只有在延迟期满的时候才能从中获取元素，放入DelayQueue中的对象，是必须实现Delayed接口的。

DelayedQueue实现工作流程如下图所示

• Poll():获取并移除队列的超时元素，没有则返回空
• take():获取并移除队列的超时元素，如果没有则wait当前线程，直到有元素满足超时条件，返回结果。

2.2 实现

定义一个类OrderDelay实现Delayed

import java.util.concurrent.Delayed;

import java.util.concurrent.TimeUnit;

public class OrderDelay implements Delayed {

    private String orderId;

    private long timeout;

    public OrderDelay(String orderId, long timeout) {

        this.orderId = orderId;

        this.timeout = timeout + System.nanoTime();

    }

    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);

    }

    // 返回距离你自定义的超时时间还有多少

    public long getDelay(TimeUnit unit) {

        return unit.convert(timeout - System.nanoTime(), TimeUnit.NANOSECONDS);

    }

    void print() {

        System.out.println(orderId + "编号的订单要删除啦。。。。");

    }

}

接下来我们新建一个测试类：

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.DelayQueue;

import java.util.concurrent.TimeUnit;

public class DelayQueueDemo {

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        List<String> list = new ArrayList<String>();

        list.add("00000001");

        list.add("00000002");

        list.add("00000003");

        list.add("00000004");

        list.add("00000005");

        DelayQueue<OrderDelay> queue = new DelayQueue<OrderDelay>();

        long start = System.currentTimeMillis();

        for (int i = 0; i < 5; i++) {

            //延迟三秒取出

            queue.put(new OrderDelay(list.get(i),

                    TimeUnit.NANOSECONDS.convert(3, TimeUnit.SECONDS)));//入队

            try {

                queue.take().print();

                System.out.println("After " +

                        (System.currentTimeMillis() - start) + " MilliSeconds");

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }
    }
}

测试结果如下：

2.3 优缺点

• 优点:效率高,任务触发时间延迟低。
• 缺点:
  (1)服务器重启后，数据全部消失，怕宕机
  (2)集群扩展相当麻烦
  (3)因为内存条件限制的原因，比如下单未付款的订单数太多，那么很容易就出现OOM异常
  (4)代码复杂度较高

3.时间轮算法

3.1 思路

时间轮算法可以类比于时钟，如上图箭头（指针）按某一个方向按固定频率轮动，每一次跳动称为一个 tick。
这样可以看出定时轮由个3个重要的属性参数，ticksPerWheel（一轮的tick数），tickDuration（一个tick的持续时间）以及 timeUnit（时间单位）
例如当ticksPerWheel=60，tickDuration=1，timeUnit=秒，这就和现实中的始终的秒针走动完全类似了。

如果当前指针指在1上面，我有一个任务需要4秒以后执行，那么这个执行的线程回调或者消息将会被放在5上。
那如果需要在20秒之后执行怎么办，由于这个环形结构槽数只到8，如果要20秒，指针需要多转2圈。位置是在2圈之后的5上面（20 % 8 + 1）

3.2 实现

我们用Netty的HashedWheelTimer来实现

3.2.1 添加maven依赖

<dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>5.0.0.Alpha2</version>
        </dependency>

3.2.2 具体实现

import io.netty.util.HashedWheelTimer;

import io.netty.util.Timeout;

import io.netty.util.Timer;

import io.netty.util.TimerTask;

import java.util.concurrent.TimeUnit;

public class HashedWheelTimerTest {

    static class MyTimerTask implements TimerTask{

        boolean flag;

        public MyTimerTask(boolean flag){

            this.flag = flag;

        }

        public void run(Timeout timeout) throws Exception {

            // TODO Auto-generated method stub

            System.out.println("要去数据库删除订单了。。。。");

            this.flag =false;

        }

    }

    public static void main(String[] argv) {

        MyTimerTask timerTask = new MyTimerTask(true);

        Timer timer = new HashedWheelTimer();

        timer.newTimeout(timerTask, 3, TimeUnit.SECONDS);//此处设置在时间轮第几个执行（本代码设置为第3格）

        int i = 1;

        while(timerTask.flag){

            try {

                Thread.sleep(1000);

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

            System.out.println(i+"秒过去了");

            i++;

        }

    }

}

测试结果如下：

3.3 优缺点

• 优点:效率高,任务触发时间延迟时间比delayQueue低，代码复杂度比delayQueue低。
• 缺点:
  (1)服务器重启后，数据全部消失，怕宕机
  (2)集群扩展相当麻烦
  (3)因为内存条件限制的原因，比如下单未付款的订单数太多，那么很容易就出现OOM异常

4.redis缓存

对于redis缓存的实现我们有两种方式：

• 1.利用redis的zset,zset是一个有序集合，每一个元素(member)都关联了一个score,通过score排序来取集合中的值
• 2.使用redis的Keyspace Notifications（键空间机制），就是利用该机制可以在key失效之后，提供一个回调，实际上是redis会给客户端发送一个消息。

4.1 利用redis的zset

添加元素:ZADD key score member [[score member] [score member] …]
按顺序查询元素:ZRANGE key start stop [WITHSCORES]
查询元素score:ZSCORE key member
移除元素:ZREM key member [member …]
下面我通过实操来给大家演示一下

添加单个元素
redis> ZADD page_rank 10 google.com
添加多个元素
redis> ZADD page_rank 9 baidu.com 8 bing.com
(integer) 2

按顺序查询元素 0 -1表示查询所有
ZRANGE page_rank 0 -1 WITHSCORES

查询元素的score值
redis> ZSCORE page_rank bing.com

移除单个元素
redis> ZREM page_rank google.com

我们具体将其和和我们要实现的功能联系在一起呢?

4.1.1 添加redis依赖

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-redis -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-redis</artifactId>
			<version>1.4.7.RELEASE</version>
		</dependency>

具体的实现如下：

import java.util.Calendar;

import java.util.Set;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.Tuple;

public class AppTest {

    private static final String ADDR = "192.168.1.2";

    private static final int PORT = 6379;

    private static JedisPool jedisPool = new JedisPool(ADDR, PORT);

    private static int waitTime = 10;//以10秒为基准

    public static Jedis getJedis() {

        return jedisPool.getResource();

    }

    //生产者,生成5个订单放进去

    public void productionDelayMessage() {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 5; i++) {

            //延迟3秒

            Calendar cal1 = Calendar.getInstance();
            waitTime += 5;//每个订单之间的间隔为5秒
            cal1.add(Calendar.SECOND, waitTime);

            int second3later = (int) (cal1.getTimeInMillis() / 1000);

            AppTest.getJedis().zadd("OrderId", second3later, "OID0000001" + i);
            long endTime = System.currentTimeMillis();

            System.out.println((endTime - startTime) / 1000 + "s:redis生成了一个订单任务：订单ID为" + "OID0000001" + i);

        }

    }

    //消费者，取订单

    public void consumerDelayMessage() {

        Jedis jedis = AppTest.getJedis();
        long startTime = System.currentTimeMillis();
        while (true) {

            Set<Tuple> items = jedis.zrangeWithScores("OrderId", 0, 1);

            if (items == null || items.isEmpty()) {

                System.out.println("当前没有等待的任务");

                try {

                    Thread.sleep(500);

                } catch (InterruptedException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

                continue;

            }

            int score = (int) ((Tuple) items.toArray()[0]).getScore();

            Calendar cal = Calendar.getInstance();

            int nowSecond = (int) (cal.getTimeInMillis() / 1000);

            if (nowSecond >= score) {

                String orderId = ((Tuple) items.toArray()[0]).getElement();

                jedis.zrem("OrderId", orderId);
                long endTime = System.currentTimeMillis();
                System.out.println((endTime - startTime) / 1000 + "s:redis消费了一个任务：消费的订单OrderId为" + orderId);

            }

        }

    }

    public static void main(String[] args) {

        AppTest appTest = new AppTest();
        appTest.productionDelayMessage();//创建消费订单
        appTest.consumerDelayMessage();//由消费者进行消费

    }

}

测试结果如下：

通过上述结果我们可以看出每隔5秒消费了一笔订单
然而上面的实现却有一个致命的问题： 在高并发条件下，多消费者会取到同一个订单号
我们使用多线程进行测试一下

import java.util.concurrent.CountDownLatch;

public class ThreadTest {

    private static final int threadNum = 10;//线程数

    private static CountDownLatch cdl = new CountDownLatch(threadNum);

    static class DelayMessage implements Runnable {

        public void run() {

            try {

                cdl.await();

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

            AppTest appTest = new AppTest();

            appTest.consumerDelayMessage();

        }

    }

    public static void main(String[] args) {

        AppTest appTest = new AppTest();

        appTest.productionDelayMessage();

        for (int i = 0; i < threadNum; i++) {

            new Thread(new DelayMessage()).start();

            cdl.countDown();

        }

    }

}

可以看出出现了多个线程消费同一个资源的情况，这种情况肯定是不允许的，所以给出两个解决方案让大家参考

• 1.用分布式锁，但是用分布式锁，性能下降了
• 2.对ZREM的返回值进行判断，只有大于0的时候，才消费数据

由于方案1涉及到java分布式锁的设计，后面我会专门出一期关于java分布式锁的内容讲解，同时也会将第一个方法的内容补全，下面我们先看看如何通过ZREM来进行解决多线程消费同一个订单的问题

4.1.2 解决多线程消费同一资源

我们将consumerDelayMessage()方法中的

改为以下内容

if (nowSecond >= score) {

                String orderId = ((Tuple) items.toArray()[0]).getElement();

                Long num = jedis.zrem("OrderId", orderId);
                long endTime = System.currentTimeMillis();
                if (num != null && num > 0) {
                    System.out.println((endTime - startTime) / 1000 + "s:redis消费了一个任务：消费的订单OrderId为" + orderId);
                }

            }

再次进行多线程的测试

4.2 使用redis的Keyspace Notifications（键空间机制）

在redis的配置文件中(redis.conf)中，加入以下配置

notify-keyspace-events Ex

具体操作代码如下：

package com.example.test.test;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPubSub;

public class RedisTest {

    private static final String ADDR = "192.168.1.2";

    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 {

        public void onMessage(String channel, String message) {

            System.out.println(System.currentTimeMillis() + "ms:" + message + "订单取消");

        }

    }

}

可以明显看到3秒过后，订单取消了
但是这种方法有个很大的弊端，redis的pub/sub机制存在一个硬伤，官网内容如下

Because Redis Pub/Sub is fire and forget currently there is no way to use this feature if your application demands reliable notification of events, that is, if your Pub/Sub client disconnects, and reconnects later, all the events delivered during the time the client was disconnected are lost.

我给大家翻译翻译什么意思

Redis的发布/订阅目前是即发即弃(fire and forget)模式的，因此无法实现事件的可靠通知。也就是说，如果发布/订阅的客户端断链之后又重连，则在客户端断链期间的所有事件都丢失了。因此，方案二不是太推荐。当然，如果你对可靠性要求不高，可以使用。

4.3 优缺点

• 优点:
  (1)由于使用Redis作为消息通道，消息都存储在Redis中。如果发送程序或者任务处理程序挂了，重启之后，还有重新处理数据的可能性。
  (2)做集群扩展相当方便
  (3)时间准确度高
• 缺点:(1)需要额外进行redis维护

5.使用消息队列

5.1 思路

我们可以采用rabbitMQ的延时队列。RabbitMQ可以针对Queue和Message设置 x-message-tt，来控制消息的生存时间，如果超时，则消息变为dead letter。

5.2 实现

5.3 优缺点

• 优点: 高效,可以利用rabbitmq的分布式特性轻易的进行横向扩展,消息支持持久化增加了可靠性。
• 缺点：本身的易用度要依赖于rabbitMq的运维.因为要引用rabbitMq,所以复杂度和成本变