精华内容
下载资源
问答
  • java实现延时处理

    2021-12-07 15:37:02
    一共有如下几点区别: 定时任务有明确的触发时间,延时任务没有 定时任务有执行周期,而延时任务在某事件触发后一段时间内执行,没有执行周期 定时任务一般执行的是批处理操作是多个任务,而延时任务一般是单个任务 ...
     
     
    

    业务场景:

    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,所以复杂度和成本变
    展开全文
  • } } 4、 用这下面的TimeTask类(指定延时java里面的sleep()并不能精确定时,TimeTask可以:例下面的小程序: import java.util.*; public class test { public static void main(String[] args) { Timer timer =...

    1、 用Thread就不会iu无法终止

    new Thread(new Runnable() {

    public void run() {

    while (true) {

    test();

    try {

    Thread.sleep(500);

    } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    private void test() {

    // TODO Auto-generated method stub

    }

    public Runnable start() {

    // TODO Auto-generated method stub

    return null;

    }

    }.start());

    2、 或者用现成的

    javax.swing.Timer timer = new javax.swing.Timer(500, new ActionListener() {   public void actionPerformed(ActionEvent e) {     repaint();   } };

    timer.start();

    3、下面这个方法测试过可以用 java非线程延时

    import java.awt.Robot;

    import java.util.Date;

    public class test {

    public   static   void   main(String[]   args)   throws   Exception{

    Robot  r   =   new   Robot();

    System.out.println( "延时前:"+new Date().toString()  );

    r.delay(   2000   );

    System.out.println(   "延时后:"+new Date().toString()   );

    }

    }

    4、 用这下面的TimeTask类(指定延时)

    java里面的sleep()并不能精确定时,TimeTask可以:例下面的小程序:

    import java.util.*;

    public class test {

    public static void main(String[] args) {

    Timer timer = new Timer();// 实例化Timer类

    timer.schedule(new TimerTask() {

    public void run() {

    System.out.println("退出");

    this.cancel();

    }

    }, 5000);// 这里百毫秒

    System.out.println("本程序存在5秒后自动退出");

    }

    }

    展开全文
  • java怎么实现延时

    2021-03-06 06:18:00
    java实现延时的方法:1、使用Timer类Timer类负责计划任务的功能,也即指定的时间开始执行某个任务。Timer类的作用只是用于设置计划任务。Timer类的schedule方法可以按照时间计划执行程序。public static void main...

    fd940323b2dbc945504c5247e76dc3ce.png

    java实现延时的方法:

    1、使用Timer类

    Timer类负责计划任务的功能,也即指定的时间开始执行某个任务。Timer类的作用只是用于设置计划任务。

    Timer类的schedule方法可以按照时间计划执行程序。public static void main(String[] args) {

    Timer timer = new Timer();

    TimerTask timerTask = new MyTimerTask();

    timer.schedule(timerTask, 10000, 10000);

    }

    schedule方法中需要传入一个TimerTask类型的对象,该对象需要继承并实现TimerTask类的run方法,或者以匿名内部类的方式实现run方法。schedule的第二个参数为程序第一次执行run方法的延时时间,第三个参数为执行完第一次run方法后延时循环执行run方法的时间。public class MyTimerTask extends TimerTask{

    String userStatus = null;

    String key1 = null;

    String key2 = null;

    Jedis jedis = new Jedis("192.168.16.100",6379);

    @Override

    public void run() {

    // TODO Auto-generated method stub

    key1 = jedis.get("key1_13681033074");

    key2 = jedis.get("key2_13681033074");

    if(key1 != null && key2 == null){

    userStatus = "进入";

    }

    if(key1 != null && key2 != null){

    if(key1.equals(key2)){

    userStatus = "驻留";

    }else {

    userStatus = "进入";

    }

    }

    if(key1 == null && key2 != null){

    userStatus = "离开";

    }

    System.out.println(userStatus);

    }

    }

    实现了run方法后就会根据schedule设置的时间计划来执行。schedule的参数也可以不要循环时间,只延时执行一次,还有多种重载的schedule方法,可以根据实际情况使用。

    2、使用Thread

    在Java中有时候需要使程序暂停一点时间,称为延时。普通延时用Thread.sleep(int)方法,这很简单。它将当前线程挂起指定的毫秒数。如try

    {

    Thread.currentThread().sleep(1000);//毫秒

    }

    catch(Exception e){}

    更多java知识请关注java基础教程栏目。

    展开全文
  • Java 两种延时thread和timer详解及实例代码Java 两种延时thread和timer详解及实例代码在Java中有时候需要使程序暂停一点时间,称为延时。普通延时用Thread.sleep(int)方法,这很简单。它将当前线程挂起指定的毫秒数...

    Java 两种延时thread和timer详解及实例代码

    Java 两种延时thread和timer详解及实例代码

    在Java中有时候需要使程序暂停一点时间,称为延时。普通延时用Thread.sleep(int)方法,这很简单。它将当前线程挂起指定的毫秒数。如

    try

    {

    Thread.currentThread().sleep(1000);//毫秒

    }

    catch(Exception e){}

    在这里需要解释一下线程沉睡的时间。sleep()方法并不能够让程序"严格"的沉睡指定的时间。例如当使用5000作为sleep()方法的参数时,线 程可能在实际被挂起5000.001毫秒后才会继续运行。当然,对于一般的应用程序来说,sleep()方法对时间控制的精度足够了。

    但是如果要使用精确延时,最好使用Timer类:

    Timer timer=new Timer();//实例化Timer类

    timer.schedule(new TimerTask(){

    public void run(){

    System.out.println("退出");

    this.cancel();}},500);//五百毫秒

    这种延时比sleep精确。上述延时方法只运行一次,如果需要运行多次, 使用timer.schedule(new MyTask(), 1000, 2000); 则每间隔2秒执行MyTask()

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    时间: 2017-02-25

    6b5aa0751a6f1e6a9d0b665a02cc1f46.gif

    1. Timer是一个定时器,它可以根据指定的时间,指定的执行周期来执行固定的任务TimerTask,例子如下: Timer与线程的关系,在Timer源代码中可现如下代码: 1. 以下为Timer的默认构造方法,起调用了自身的一个有参构造函数: 2.有参构造函数代码如下: 3. 有参构造函数设置了当前线程的名字并启动该线程,线程代码如下: 4. TimerThread类的源代码如下: 由以上代码可以看出Timer其实就是一个Thread类的子类. TimerTask与线程的关系: 1. 以下为T

    个人对于laravel orm 中对于一对多关系的理解 文章表 article,文章自然可以评论,表 comment 记录文章的评论,文章和评论的关系就是一对多,一篇文章可以有多个评论. 在 comment 表中有字段 article 记录评论所属文章,文章和评论的关系如下: article:id  ... ... comment : id ... ... article_id  在 comment 表中有关联 article 的外键 article_id,所以在 Comment 模型中是 be

    loss函数如何接受输入值 keras封装的比较厉害,官网给的例子写的云里雾里, 在stackoverflow找到了答案 You can wrap the loss function as a inner function and pass your input tensor to it (as commonly done when passing additional arguments to the loss function). def custom_loss_wrapper(input_

    Spring和SpringMVC的容器具有父子关系,Spring容器为父容器,SpringMVC为子容器,子容器可以引用父容器中的Bean,而父容器不可以引用子容器中的Bean. 了解了Spring与SpringMVC父子容器的关系,接下来让我们看看Spring与SpringMVC容器的初始化过程. 以下讲解使用的web.xml文件如下: contextConfigLocation//指定

    在Android中子线程是不能更新ui的. 所以我们要通过其他方式来动态改变ui视图, 1.runOnUiThread activity提供的一个轻量级更新ui的方法,在Fragment需要使用的时候要用getActivity.runOnUiThread开启线程 这种方法最简单,方便更新一些不需要判断的通知,比如在聊天项目中动态获取未读消息数量. runOnUiThread(new Runnable() { @Override public void run() { sendMessage("[

    多线程并发处理起来通常比较麻烦,如果你使用spring容器来管理业务bean,事情就好办了多了.spring封装了Java的多线程的实现,你只需要关注于并发事物的流程以及一些并发负载量等特性,具体来说如何使用spring来处理并发事务: 1.了解 TaskExecutor接口 Spring的TaskExecutor接口等同于java.util.concurrent.Executor接口. 实际上,它存在的主要原因是为了在使用线程池的时候,将对Java5的依赖抽象出来. 这个接口只有一个方法exe

    0704cd876a1676a44266922604fbfbc8.png

    Java中的wait/notify/notifyAll可用来实现线程间通信,是Object类的方法,这三个方法都是native方法,是平台相关的,常用来实现生产者/消费者模式.先来我们来看下相关定义: wait() :调用该方法的线程进入WATTING状态,只有等待另外线程的通知或中断才会返回,调用wait()方法后,会释放对象的锁. wait(long):超时等待最多long毫秒,如果没有通知就超时返回. notify() :通知一个在对象上等待的线程,使其从wait()方法返回,而返回的前提

    96566499b1746a9ac7b30cd7d9ad4ea2.png

    1. 新建( new ):新创建了一个线程对象. 2. 可运行( runnable ):线程对象创建后,其他线程(比如 main 线程)调用了该对象 的 start ()方法.该状态的线程位于可运行线程池中,等待被线程调度选中,获 取 cpu 的使用权 . 3. 运行( running ):可运行状态( runnable )的线程获得了 cpu 时间片( timeslice ) ,执行程序代码. 4. 阻塞( block ):阻塞状态是指线程因为某种原因放弃了 cpu 使用权,也即让出了 cpu

    处理器总处于以下状态中的一种: 1.内核态,运行于进程上下文,内核代表进程运行于内核空间: 2.内核态,运行于中断上下文,内核代表硬件运行于内核空间: 3.用户态,运行于用户空间: 一个进程的上下文可以分为三个部分:用户级上下文.寄存器上下文以及系统级上下文. 用户级上下文:  正文.数据.用户堆栈以及共享存储区: 寄存器上下文:  通用寄存器.程序寄存器(IP).处理器状态寄存器(EFLAGS).栈指针(ESP): 系统级上下文:  进程控制块task_struct.内存管理信息(mm_str

    1. 为什么使用线程池 诸如 Web 服务器.数据库服务器.文件服务器或邮件服务器之类的许多服务器应用程序都面向处理来自某些远程来源的大量短小的任务.请求以某种方式到达服务器,这种方式可能是通过网络协议(例如 HTTP.FTP 或 POP).通过 JMS 队列或者可能通过轮询数据库.不管请求如何到达,服务器应用程序中经常出现的情况是:单个任务处理的时间很短而请求的数目却是巨大的. 构建服务器应用程序的一个简单模型是:每当一个请求到达就创建一个新线程,然后在新线程中为请求服务.实际上对于原型开发这

    展开全文
  • Java延时任务

    2021-09-10 11:02:14
    定时任务有执行周期,而延时任务在某事件触发后一段时间内执行,没有执行周期 定时任务一般执行的是批处理操作是多个任务,而延时任务一般是单个任务 下面,我们以判断订单是否超时为例,进行方案分析 方案分析 ...
  • 1、利用延迟队列延时队列,第...延时1分钟再次执行等,下面先看看延时队列demo之后再看延时队列在项目中的使用:简单的延时队列要有三部分:第一实现了Delayed接口的消息体、第二消费消息的消费者、第三存放消息的延...
  • 通常同步意味着一个任务的某个处理过程会对多个线程在用串行化处理,而异步则意味着某个处理过程可以允许多个线程同时处理。下面我们就来看看有关异步处理的详细内容。异步通常代表着更好的性能,因为它很大程度上...
  • Java - Redis 实现延时消息队列什么是延时任务延时任务的特点实现思路:代码实现使用事例 什么是延时任务 延时任务,顾名思义,就是延迟一段时间后才执行的任务。举个例子,假设我们有个发布资讯的功能,运营需要在...
  • 使用DelayQueue保存当天将会执行的任务和执行时间,一旦从DelayQueue中获取到任务就开始执行,从比如TimerQueue就是使用DelayQueue实现的。 队列中的Delayed必须实现compareTo来指定元素的顺序。比如让延时时间最长...
  • java.util.concurrent.ScheduledThreadPoolExecutor 是JDK1 .6之后自带的包,功能强大,能实现定时器和延时加载的功能各类功能和处理方面优于Timer1、定时器:ScheduledThreadPoolExecutor 有个scheduleAtFixedRate...
  • 1、最简单直接的使用Handler PostDelayjavanew Handler().postDelayed(new Runnable(){public void run() {//execute ...*2、 开启一个新的线程javanew Thread(new Runnable(){public void run(){Thread.sleep(del...
  • Redis zset延时队列简单实现(Java

    千次阅读 2021-03-22 16:22:11
    业务上有个简单的延时队列的需求(对下单超过15分钟没有支付的订单进行取消操作),整个消息中间件吧,项目上以前本身也没设立消息中间件,加一个似乎也没必要,对方不会运维的话,就惨了。 轮询查找订单表吧?订单...
  • 服务器通信串行执行任务任务执行最简单的策略就是在单线程中串行执行各项任务,并不会涉及多线程。以创建通讯服务为例,我们可以这样实现(很low)@Testpublic void singleThread() throws IOException {ServerSocket ...
  • Java如何实现延时访问

    2021-03-15 01:24:26
    调用某个方法后,我们需要程序过一段时间再去处理,就可以用多线程阻塞或Timer定时器来实现方法一多线程阻塞实现方式MyTaskpackage abc;import java.util.concurrent.*;public class MyTask implements Callable {...
  • 同步与异步通常同步意味着一个任务的某个处理过程会对多个线程在用串行化处理,而异步则意味着某个处理过程可以允许多个线程同时处理。异步通常代表着更好的性能,因为它很大程度上依赖于缓冲,是典型的使用空间换...
  • 为此实现了一个简单的延迟任务处理器,主要思路是将任务放入DelayQueue,由一个专用线程从DelayQueue中取出到期的任务,放入执行线程池中执行。整体比较简单。 import ...
  • 一个java线程,功能是实现每个整点(本机时间)执行一次,即11:00:00执行一次,12:00:00、13:00:00 ...20:00:00 每个整点执行。package com.jwnie.thread;import java.text.ParseException;import java.text....
  • 本文涉及Java编程中异步处理机制的简单介绍和一个相关实例,相信通过这篇文章,大家能对异步处理有更多的了解。通常同步意味着一个任务的某个处理过程会对多个线程在用串行化处理,而异步则意味着某个处理过程可以...
  • Java中的计划任务Timer工具类提供了以计时器或计划任务的功能来实现按指定时间或时间间隔执行任务,但由于Timer工具类并不是以池pool方式实现的,而是以队列的方式来管理线程的,所以在高并发的情况下运行效率较低,...
  • 在我们的工作中,很多地方使用延迟队列,比如订单到期没有付款取消订单...我们知道目前JAVA可以有DelayedQueue,我们首先开一个DelayQueue的结构类图。DelayQueue实现了Delay、BlockingQueue接口。也就是DelayQueue是...
  • 1.延时队列DealyQueue中要添加的元素必须实现Dealyed接口,并且是重写Dealayed中的getDelay()和compareTo()方法. 2.compareTo()方法的使用可以见我之前的文章,而getDelay方法,如果此方法返回的值小0或者等于0,...
  • 1、定义延时订单类 定义唯一的订单编号、超时时间、类型等字段 类需要实现Delayed, Serializable 接口 import lombok.Data; import java.io.Serializable; import java.util.Date; import java.util.concurrent....
  • 我们在使用Android系统时,是不是会经常遇见卡机的问题,经常我是直接关机或者重新启动,然后就可以好了,但是也有更专业化的技术来android中延迟执行某个任务,那么我们就来讲讲这个延迟的问题。一、开启新线程1 ...
  • 我用的是newScheduledThreadPool这种方法做周期性定时任务的,目前发现运行了一段时间都正常,过了几天后,有些定时任务会莫名其妙的不执行,也不报错。比如代码块://开启定时对应数量的任务线程池ScheduledExecuto...
  • 声明:本文是《 Java 7 Concurrency Cookbook》的第四章,作者: Javier Fernández González 译者:许巧辉 校对:方腾飞,叶磊执行者延迟运行一个任务执行者框架提供ThreadPoolExecutor类,使用池中的线程来执行...
  • 作者: 一字马胡转载标志 【2017-11-03】更新日志日期更新内容备注2017-11-03添加转载标志持续更新如果在一个ScheduleExecutorService中提交一个任务,这个任务的调度周期设置的时间比任务本身执行的时间短的话会...
  • Java接口异步调用

    2021-03-09 17:20:36
    前言java接口调用从调用方式上可以分为3类:同步调用,异步调用,回调;同步调用基本不用说了,它是一种阻塞式的调用,就是A方法中直接调用方法B,从上往下依次执行。今天来说说异步调用。什么是异步调用?我的理解...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,074
精华内容 22,029
关键字:

java延时处理执行

java 订阅