精华内容
下载资源
问答
  • ![图片说明](https://img-ask.csdn.net/upload/201605/24/1464075713_246860.png) 这是使用javafx做的一个界面:1.... 请问在不用Timer 和TimerTask等util工具类 ,用线程怎么实现点击按钮来定时添加数据和停止添加功能
  • java使用线程实现定时功能 解决方法: 1.定义一个线程 http://www.yayihouse.com/yayishuwu/chapter/1485

    java使用线程实现定时功能

    解决方法:

    1.定义一个线程

    http://www.yayihouse.com/yayishuwu/chapter/1485

    展开全文
  • 基于Java线程实现后台定时监控

    千次阅读 2011-05-22 21:18:00
    但是如何在Java服务端来实现这样一个监控机制呢?一般大家都会想到线程。但是一直以来,都没有亲身动手实践过。趁着工作间隙,自己也搬出一段代码来,与大家一起分享线程编程的神奇魔力。 首先创建一个基本抽象...

    转载:http://littlefermat.blog.163.com/blog/static/59771167200928115047810/

    熟悉编写JavaScript的人,都习惯在页面写入setTimeOut来实现web页面的定时监控或事务处理。但是如何在Java服务端来实现这样一个监控机制呢?一般大家都会想到线程。但是一直以来,都没有亲身动手实践过。趁着工作间隙,自己也搬出一段代码来,与大家一起分享线程编程的神奇魔力。

    首先创建一个基本抽象类SchedThread,代码内容如下:

    Java代码 复制代码
    1. package com.test;   
    2.   
    3. /**  
    4.  * 基于Java线程实现后台定时监控 <p/> Created: Mar 26, 2008 10:08:43 <p/>  
    5.  * <h4>http://tailsherry.javaeye.com</h4>  
    6.  * <p/>  
    7.  *   
    8.  * @author TailSherry  
    9.  */  
    10. public abstract class SchedThread   
    11. {   
    12.     protected static final long NEVER = Long.MAX_VALUE;   
    13.   
    14.     // 定义一个线程锁,保证当前只有一个工作在操作中   
    15.     private final Object lock = new Object();   
    16.   
    17.     // 定义一个Thread变量   
    18.     private Thread thread;   
    19.   
    20.     // 控制线程循环的开关   
    21.     private boolean active = true;   
    22.   
    23.     // 定义一个毫秒级的时间变量,指示何时执行下一个操作   
    24.     private long nextTime;   
    25.   
    26.     /**  
    27.      * 定义个一个抽象的方法用来获取下一个执行操作的时间,可使用NEVER  
    28.      */  
    29.     protected abstract long getNextTime();   
    30.   
    31.     /**  
    32.      * 定义一个抽象的方法,让子类来定义具体的工作过程  
    33.      */  
    34.     protected abstract void executeWork();   
    35.   
    36.     protected String getName()   
    37.     {   
    38.         return getClass().getName();   
    39.     }   
    40.   
    41.     /**  
    42.      * 启动线程  
    43.      */  
    44.     public void start()   
    45.     {   
    46.         thread = new Thread(new Runnable()   
    47.         {   
    48.             public void run()   
    49.             {   
    50.                 runInternal();   
    51.             }   
    52.         }, getName());   
    53.         thread.start();   
    54.     }   
    55.   
    56.     /**  
    57.      * 强迫停止线程,跳出for循环  
    58.      */  
    59.     public void stop() throws InterruptedException   
    60.     {   
    61.         synchronized (lock)   
    62.         {   
    63.             active = false;   
    64.             lock.notify();   
    65.         }   
    66.         thread.join();   
    67.     }   
    68.   
    69.     /**  
    70.      * 此方法可以在任何时候激活当前线程,让线程进入工作执行环节  
    71.      */  
    72.     public void workAdded(long time)   
    73.     {   
    74.         synchronized (lock)   
    75.         {   
    76.             if (time < nextTime)   
    77.             {   
    78.                 // 立刻激活线程工作继续运行   
    79.                 lock.notify();   
    80.             }   
    81.         }   
    82.     }   
    83.   
    84.     /**  
    85.      * 线程监测控制逻辑部分  
    86.      */  
    87.     private void runInternal()   
    88.     {   
    89.         // 无限循环   
    90.         for (;;)   
    91.         {   
    92.             // 该过程忽略了所有的Exception,以保证线程不会因此而中断   
    93.             try  
    94.             {   
    95.                 synchronized (lock)   
    96.                 {   
    97.                     nextTime = getNextTime();   
    98.                     // 获得时间区间,即要等待的时间段   
    99.                     long interval = nextTime - System.currentTimeMillis();   
    100.                     if (interval > 0)   
    101.                     {   
    102.                         try  
    103.                         {   
    104.                             lock.wait(interval);   
    105.                         }   
    106.                         catch (InterruptedException e)   
    107.                         {   
    108.                             // 忽略此Exception   
    109.                         }   
    110.                     }   
    111.                     // 如果active为false,强制中断   
    112.                     if (!active)   
    113.                     {   
    114.                         break;   
    115.                     }   
    116.                 }   
    117.                 // 执行具体的工作   
    118.                 executeWork();   
    119.             }   
    120.             catch (Throwable t)   
    121.             {   
    122.                 try  
    123.                 {   
    124.                     Thread.sleep(10000);   
    125.                 }   
    126.                 catch (InterruptedException ie)   
    127.                 {   
    128.                     // 忽略此Exception   
    129.                 }   
    130.             }   
    131.         }   
    132.     }   
    133. }  
    package com.test;
    
    /**
     * 基于Java线程实现后台定时监控 <p/> Created: Mar 26, 2008 10:08:43 <p/>
     * <h4>http://tailsherry.javaeye.com</h4>
     * <p/>
     * 
     * @author TailSherry
     */
    public abstract class SchedThread
    {
        protected static final long NEVER = Long.MAX_VALUE;
    
        // 定义一个线程锁,保证当前只有一个工作在操作中
        private final Object lock = new Object();
    
        // 定义一个Thread变量
        private Thread thread;
    
        // 控制线程循环的开关
        private boolean active = true;
    
        // 定义一个毫秒级的时间变量,指示何时执行下一个操作
        private long nextTime;
    
        /**
         * 定义个一个抽象的方法用来获取下一个执行操作的时间,可使用NEVER
         */
        protected abstract long getNextTime();
    
        /**
         * 定义一个抽象的方法,让子类来定义具体的工作过程
         */
        protected abstract void executeWork();
    
        protected String getName()
        {
            return getClass().getName();
        }
    
        /**
         * 启动线程
         */
        public void start()
        {
            thread = new Thread(new Runnable()
            {
                public void run()
                {
                    runInternal();
                }
            }, getName());
            thread.start();
        }
    
        /**
         * 强迫停止线程,跳出for循环
         */
        public void stop() throws InterruptedException
        {
            synchronized (lock)
            {
                active = false;
                lock.notify();
            }
            thread.join();
        }
    
        /**
         * 此方法可以在任何时候激活当前线程,让线程进入工作执行环节
         */
        public void workAdded(long time)
        {
            synchronized (lock)
            {
                if (time < nextTime)
                {
                    // 立刻激活线程工作继续运行
                    lock.notify();
                }
            }
        }
    
        /**
         * 线程监测控制逻辑部分
         */
        private void runInternal()
        {
            // 无限循环
            for (;;)
            {
                // 该过程忽略了所有的Exception,以保证线程不会因此而中断
                try
                {
                    synchronized (lock)
                    {
                        nextTime = getNextTime();
                        // 获得时间区间,即要等待的时间段
                        long interval = nextTime - System.currentTimeMillis();
                        if (interval > 0)
                        {
                            try
                            {
                                lock.wait(interval);
                            }
                            catch (InterruptedException e)
                            {
                                // 忽略此Exception
                            }
                        }
                        // 如果active为false,强制中断
                        if (!active)
                        {
                            break;
                        }
                    }
                    // 执行具体的工作
                    executeWork();
                }
                catch (Throwable t)
                {
                    try
                    {
                        Thread.sleep(10000);
                    }
                    catch (InterruptedException ie)
                    {
                        // 忽略此Exception
                    }
                }
            }
        }
    }

     

    以上这个类非常关键,基本上已经实现了所有的控制逻辑,如此再扩展出一个实现类出来,比如这里我写了一个模拟实现类MyDataGenerator,大家可以参考一下:

    Java代码 复制代码
    1. package com.test;   
    2.   
    3. public class MyDataGenerator extends SchedThread {   
    4.     protected void executeWork() {   
    5.         System.out.println("Execute work ...");   
    6.     }   
    7.   
    8.     protected long getNextTime() {   
    9.         return System.currentTimeMillis() + 2000L;   
    10.     }   
    11.   
    12.     public static void main(String argv[]) {   
    13.         MyDataGenerator generator = new MyDataGenerator();   
    14.         generator.start();   
    15.     }   
    16. }  
    package com.test;
    
    public class MyDataGenerator extends SchedThread {
        protected void executeWork() {
            System.out.println("Execute work ...");
        }
    
        protected long getNextTime() {
            return System.currentTimeMillis() + 2000L;
        }
    
        public static void main(String argv[]) {
            MyDataGenerator generator = new MyDataGenerator();
            generator.start();
        }
    }

      

    当然这里没有使用workAdded和stop等功能,可以留给大家扩展。

    展开全文
  • Java实现线程定时执行任务代码发布时间:2020-05-30 12:23:37来源:亿速云阅读:144作者:鸽子Java线程中的定时器(java.util.Timer)有定时执行任务的功能,通过设定定时器的间隔时间,会自动在此间隔后执行预先...

    Java实现多线程定时执行任务代码

    发布时间:2020-05-30 12:23:37

    来源:亿速云

    阅读:144

    作者:鸽子

    Java多线程中的定时器(java.util.Timer)有定时执行任务的功能,通过设定定时器的间隔时间,会自动在此间隔后执行预先安排好的任务(java.util.TimerTask)。

    timer.schedule(TimerTask,delay,interval time)

    第一个参数是需要执行的任务。此类的类型为java.util.TimerTask。第二个参数是执行任务前等待时间,第三个参数是间隔时间(单位为毫秒)

    package timer;

    import java.util.concurrent.PriorityBlockingQueue;

    public class MyTimer {

    PriorityBlockingQueue queue = new PriorityBlockingQueue<>();

    Worker worker;private static class Worker extends Thread {

    PriorityBlockingQueue queue;

    Worker(PriorityBlockingQueue queue) {

    this.queue = queue;

    }

    @Override

    public void run() {

    while (true) {

    try {

    MyTimerTask task = queue.take();

    long current = System.currentTimeMillis();

    if (task.delay <= current) {

    task.target.run();

    } else {

    queue.put(task);

    Thread.sleep(task.delay - current);

    }

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    }

    MyTimer() {

    worker = new Worker(queue);

    worker.start();

    }

    void execute(Runnable target, long delay) {

    queue.put(new MyTimerTask(target, delay));

    }

    public static void main(String[] args) {

    MyTimer timer = new MyTimer();

    timer.execute(new Runnable() {

    @Override

    public void run() {

    System.out.println("该起床了");

    }

    }, 2000);

    System.out.println("另一个人");

    }

    }

    package timer;

    public class MyTimerTask implements Comparable {

    Runnable target;

    long delay;MyTimerTask(Runnable target, long delay) {

    this.target = target;

    this.delay = System.currentTimeMillis() + delay;//延时后的时刻

    }

    @Override

    public int compareTo(MyTimerTask o) {

    if (delay == o.delay) {

    //延时后的时刻

    return 0;

    } else if (delay < o.delay) {

    return -1;

    } else {

    return 1;

    }

    }

    }

    展开全文
  • 在我们编程过程中如果需要执行一些简单的定时任务,无须做复杂的控制,我们可以考虑使用JDK中的Timer定时任务来实现。下面LZ就其原理、实例以及Timer缺陷三个方面来解析java Timer定时器。一、简介在java中一个完整...

    在我们编程过程中如果需要执行一些简单的定时任务,无须做复杂的控制,我们可以考虑使用JDK中的Timer定时任务来实现。下面LZ就其原理、实例以及Timer缺陷三个方面来解析java Timer定时器。

    一、简介

    在java中一个完整定时任务需要由Timer、TimerTask两个类来配合完成。 API中是这样定义他们的,Timer:一种工具,线程用其安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行。由TimerTask:Timer 安排为一次执行或重复执行的任务。我们可以这样理解Timer是一种定时器工具,用来在一个后台线程计划执行指定任务,而TimerTask一个抽象类,它的子类代表一个可以被Timer计划的任务。

    Timer类

    在工具类Timer中,提供了四个构造方法,每个构造方法都启动了计时器线程,同时Timer类可以保证多个线程可以共享单个Timer对象而无需进行外部同步,所以Timer类是线程安全的。但是由于每一个Timer对象对应的是单个后台线程,用于顺序执行所有的计时器任务,一般情况下我们的线程任务执行所消耗的时间应该非常短,但是由于特殊情况导致某个定时器任务执行的时间太长,那么他就会“独占”计时器的任务执行线程,其后的所有线程都必须等待它执行完,这就会延迟后续任务的执行,使这些任务堆积在一起,具体情况我们后面分析。

    当程序初始化完成Timer后,定时任务就会按照我们设定的时间去执行,Timer提供了schedule方法,该方法有多中重载方式来适应不同的情况,如下:

    schedule(TimerTask task, Date time):安排在指定的时间执行指定的任务。

    schedule(TimerTask task, Date firstTime, long period) :安排指定的任务在指定的时间开始进行重复的固定延迟执行。

    schedule(TimerTask task, long delay) :安排在指定延迟后执行指定的任务。

    schedule(TimerTask task, long delay, long period) :安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。

    同时也重载了scheduleAtFixedRate方法,scheduleAtFixedRate方法与schedule相同,只不过他们的侧重点不同,区别后面分析。

    scheduleAtFixedRate(TimerTask task, Date firstTime, long period):安排指定的任务在指定的时间开始进行重复的固定速率执行。

    scheduleAtFixedRate(TimerTask task, long delay, long period):安排指定的任务在指定的延迟后开始进行重复的固定速率执行。

    TimerTask

    TimerTask类是一个抽象类,由Timer 安排为一次执行或重复执行的任务。它有一个抽象方法run()方法,该方法用于执行相应计时器任务要执行的操作。因此每一个具体的任务类都必须继承TimerTask,然后重写run()方法。

    另外它还有两个非抽象的方法:

    boolean cancel():取消此计时器任务。

    long scheduledExecutionTime():返回此任务最近实际执行的安排执行时间。

    二、实例

    2.1、指定延迟时间执行定时任务

    public class TimerTest01 {

    Timer timer;

    public TimerTest01(int time){

    timer = new Timer();

    timer.schedule(new TimerTaskTest01(), time * 1000);

    }

    public static void main(String[] args) {

    System.out.println("timer begin....");

    new TimerTest01(3);

    }

    }

    public class TimerTaskTest01 extends TimerTask{

    public void run() {

    System.out.println("Time's up!!!!");

    }

    }

    运行结果:

    首先打印:timer begin....

    3秒后打印:Time's up!!!!

    2.2、在指定时间执行定时任务 [code]public class TimerTest02 { Timer timer;

    public class TimerTest02 {

    Timer timer;

    public TimerTest02(){

    Date time = getTime();

    System.out.println("指定时间time=" + time);

    timer = new Timer();

    timer.schedule(new TimerTaskTest02(), time);

    }

    public Date getTime(){

    Calendar calendar = Calendar.getInstance();

    calendar.set(Calendar.HOUR_OF_DAY, 11);

    calendar.set(Calendar.MINUTE, 39);

    calendar.set(Calendar.SECOND, 00);

    Date time = calendar.getTime();

    return time;

    }

    public static void main(String[] args) {

    new TimerTest02();

    }

    }

    public class TimerTaskTest02 extends TimerTask{

    @Override

    public void run() {

    System.out.println("指定时间执行线程任务...");

    }

    }

    当时间到达11:39:00时就会执行该线程任务,当然大于该时间也会执行!!执行结果为:

    指定时间time=Tue Jun 10 11:39:00 CST 2014

    指定时间执行线程任务...

    2.3、在延迟指定时间后以指定的间隔时间循环执行定时任务

    public class TimerTest03 {

    Timer timer;

    public TimerTest03(){

    timer = new Timer();

    timer.schedule(new TimerTaskTest03(), 1000, 2000);

    }

    public static void main(String[] args) {

    new TimerTest03();

    }

    }

    public class TimerTaskTest03 extends TimerTask{

    @Override

    public void run() {

    Date date = new Date(this.scheduledExecutionTime());

    System.out.println("本次执行该线程的时间为:" + date);

    }

    }

    运行结果:

    本次执行该线程的时间为:Tue Jun 10 21:19:47 CST 2014

    本次执行该线程的时间为:Tue Jun 10 21:19:49 CST 2014

    本次执行该线程的时间为:Tue Jun 10 21:19:51 CST 2014

    本次执行该线程的时间为:Tue Jun 10 21:19:53 CST 2014

    本次执行该线程的时间为:Tue Jun 10 21:19:55 CST 2014

    本次执行该线程的时间为:Tue Jun 10 21:19:57 CST 2014

    .................

    对于这个线程任务,如果我们不将该任务停止,他会一直运行下去。

    对于上面三个实例,LZ只是简单的演示了一下,同时也没有讲解scheduleAtFixedRate方法的例子,其实该方法与schedule方法一样!

    2.4、分析schedule和scheduleAtFixedRate

    1、schedule(TimerTask task, Date time)、schedule(TimerTask task, long delay)

    对于这两个方法而言,如果指定的计划执行时间scheduledExecutionTime<= systemCurrentTime,则task会被立即执行。scheduledExecutionTime不会因为某一个task的过度执行而改变。

    2、schedule(TimerTask task, Date firstTime, long period)、schedule(TimerTask task, long delay, long period)

    这两个方法与上面两个就有点儿不同的,前面提过Timer的计时器任务会因为前一个任务执行时间较长而延时。在这两个方法中,每一次执行的task的计划时间会随着前一个task的实际时间而发生改变,也就是scheduledExecutionTime(n+1)=realExecutionTime(n)+periodTime。也就是说如果第n个task由于某种情况导致这次的执行时间过程,最后导致systemCurrentTime>= scheduledExecutionTime(n+1),这是第n+1个task并不会因为到时了而执行,他会等待第n个task执行完之后再执行,那么这样势必会导致n+2个的执行实现scheduledExecutionTime放生改变即scheduledExecutionTime(n+2) = realExecutionTime(n+1)+periodTime。所以这两个方法更加注重保存间隔时间的稳定。

    3、scheduleAtFixedRate(TimerTask task, Date firstTime, long period)、scheduleAtFixedRate(TimerTask task, long delay, long period)

    在前面也提过scheduleAtFixedRate与schedule方法的侧重点不同,schedule方法侧重保存间隔时间的稳定,而scheduleAtFixedRate方法更加侧重于保持执行频率的稳定。为什么这么说,原因如下。在schedule方法中会因为前一个任务的延迟而导致其后面的定时任务延时,而scheduleAtFixedRate方法则不会,如果第n个task执行时间过长导致systemCurrentTime>= scheduledExecutionTime(n+1),则不会做任何等待他会立即执行第n+1个task,所以scheduleAtFixedRate方法执行时间的计算方法不同于schedule,而是scheduledExecutionTime(n)=firstExecuteTime +n*periodTime,该计算方法永远保持不变。所以scheduleAtFixedRate更加侧重于保持执行频率的稳定。

    三、Timer的缺陷

    3.1、Timer的缺陷

    Timer计时器可以定时(指定时间执行任务)、延迟(延迟5秒执行任务)、周期性地执行任务(每隔个1秒执行任务),但是,Timer存在一些缺陷。首先Timer对调度的支持是基于绝对时间的,而不是相对时间,所以它对系统时间的改变非常敏感。其次Timer线程是不会捕获异常的,如果TimerTask抛出的了未检查异常则会导致Timer线程终止,同时Timer也不会重新恢复线程的执行,他会错误的认为整个Timer线程都会取消。同时,已经被安排单尚未执行的TimerTask也不会再执行了,新的任务也不能被调度。故如果TimerTask抛出未检查的异常,Timer将会产生无法预料的行为。

    1、Timer管理时间延迟缺陷

    前面Timer在执行定时任务时只会创建一个线程任务,如果存在多个线程,若其中某个线程因为某种原因而导致线程任务执行时间过长,超过了两个任务的间隔时间,会发生一些缺陷:

    public class TimerTest04 {

    private Timer timer;

    public long start;

    public TimerTest04(){

    this.timer = new Timer();

    start = System.currentTimeMillis();

    }

    public void timerOne(){

    timer.schedule(new TimerTask() {

    public void run() {

    System.out.println("timerOne invoked ,the time:" + (System.currentTimeMillis() - start));

    try {

    Thread.sleep(4000); //线程休眠3000

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }, 1000);

    }

    public void timerTwo(){

    timer.schedule(new TimerTask() {

    public void run() {

    System.out.println("timerOne invoked ,the time:" + (System.currentTimeMillis() - start));

    }

    }, 3000);

    }

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

    TimerTest04 test = new TimerTest04();

    test.timerOne();

    test.timerTwo();

    }

    }

    按照我们正常思路,timerTwo应该是在3s后执行,其结果应该是:

    timerOne invoked ,the time:1001

    timerOne invoked ,the time:3001

    但是事与愿违,timerOne由于sleep(4000),休眠了4S,同时Timer内部是一个线程,导致timeOne所需的时间超过了间隔时间,结果:

    timerOne invoked ,the time:1000

    timerOne invoked ,the time:5000

    2、Timer抛出异常缺陷

    如果TimerTask抛出RuntimeException,Timer会终止所有任务的运行。如下:

    public class TimerTest04 {

    private Timer timer;

    public TimerTest04(){

    this.timer = new Timer();

    }

    public void timerOne(){

    timer.schedule(new TimerTask() {

    public void run() {

    throw new RuntimeException();

    }

    }, 1000);

    }

    public void timerTwo(){

    timer.schedule(new TimerTask() {

    public void run() {

    System.out.println("我会不会执行呢??");

    }

    }, 1000);

    }

    public static void main(String[] args) {

    TimerTest04 test = new TimerTest04();

    test.timerOne();

    test.timerTwo();

    }

    }

    运行结果:timerOne抛出异常,导致timerTwo任务终止。

    Exception in thread "Timer-0" java.lang.RuntimeException

    at com.chenssy.timer.TimerTest04$1.run(TimerTest04.java:25)

    at java.util.TimerThread.mainLoop(Timer.java:555)

    at java.util.TimerThread.run(Timer.java:505)

    对于Timer的缺陷,我们可以考虑 ScheduledThreadPoolExecutor 来替代。Timer是基于绝对时间的,对系统时间比较敏感,而ScheduledThreadPoolExecutor 则是基于相对时间;Timer是内部是单一线程,而ScheduledThreadPoolExecutor内部是个线程池,所以可以支持多个任务并发执行。

    3.2、用ScheduledExecutorService替代Timer

    1、解决问题一:

    public class ScheduledExecutorTest {

    private ScheduledExecutorService scheduExec;

    public long start;

    ScheduledExecutorTest(){

    this.scheduExec = Executors.newScheduledThreadPool(2);

    this.start = System.currentTimeMillis();

    }

    public void timerOne(){

    scheduExec.schedule(new Runnable() {

    public void run() {

    System.out.println("timerOne,the time:" + (System.currentTimeMillis() - start));

    try {

    Thread.sleep(4000);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    },1000,TimeUnit.MILLISECONDS);

    }

    public void timerTwo(){

    scheduExec.schedule(new Runnable() {

    public void run() {

    System.out.println("timerTwo,the time:" + (System.currentTimeMillis() - start));

    }

    },2000,TimeUnit.MILLISECONDS);

    }

    public static void main(String[] args) {

    ScheduledExecutorTest test = new ScheduledExecutorTest();

    test.timerOne();

    test.timerTwo();

    }

    }

    运行结果:

    timerOne,the time:1003

    timerTwo,the time:2005

    2、解决问题二

    public class ScheduledExecutorTest {

    private ScheduledExecutorService scheduExec;

    public long start;

    ScheduledExecutorTest(){

    this.scheduExec = Executors.newScheduledThreadPool(2);

    this.start = System.currentTimeMillis();

    }

    public void timerOne(){

    scheduExec.schedule(new Runnable() {

    public void run() {

    throw new RuntimeException();

    }

    },1000,TimeUnit.MILLISECONDS);

    }

    public void timerTwo(){

    scheduExec.scheduleAtFixedRate(new Runnable() {

    public void run() {

    System.out.println("timerTwo invoked .....");

    }

    },2000,500,TimeUnit.MILLISECONDS);

    }

    public static void main(String[] args) {

    ScheduledExecutorTest test = new ScheduledExecutorTest();

    test.timerOne();

    test.timerTwo();

    }

    }

    运行结果:

    timerTwo invoked .....

    timerTwo invoked .....

    timerTwo invoked .....

    timerTwo invoked .....

    timerTwo invoked .....

    timerTwo invoked .....

    timerTwo invoked .....

    timerTwo invoked .....

    timerTwo invoked .....

    ........................

    到此这篇关于Java如何实现定时任务的文章就介绍到这了,更多相关Java定时任务内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    展开全文
  • Java中Timer是java.util包中的一个工具类,提供了定时器的功能。我们可以创建一个Timer对象,然后调用其schedule方法在某个特定的时间去执行一个特定的任务。并且你可以让其以特定频率一直执行某个任务,这个任务...
  • Java中多线程实现方式有三种:继承T
  • 在一些程序执行时,可能要我们去定时去执行某个方法,例如在指定时间进行对数据库中的数据进行修改或者清空,实现该种形式有几种方法,一是在使用spring的调度进行实现,而是使用线程进行定时实现;此主要了解以线程...
  • 线程实现定时任务

    千次阅读 2018-05-08 17:40:17
    import java.util.Calendar; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class Test { public static void main(String[] args) { test4(); ...
  • 本篇主要描述一下spring的多线程的使用与定时任务的使用.1.spring多线程任务的使用spring通过任务执行器TaskExecutor来实现线程与并发编程。通常使用ThreadPoolTaskExecutor来实现一个基于线程池的TaskExecutor....
  • 网上资料:我们可以使用Timer和TimerTask类在java实现定时任务,详细说明如下:1、基础知识java.util.Timer一种线程设施,用于安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行。此类是线程...
  • 刚刚看了下Spring Boot实现定时任务的文章,感觉还不错。Spring Boot 使用Spring自带的Schedule来实现定时任务变得非常简单和方便。在这里个大家分享下。开启缓存注解@SpringBootApplication@EnableScheduling //...
  • class Ceshi{ public static void main(String[] args){ OneSecond one... 更详细的解决办法参考 : http://passport.baidu.com/?logout&u=http%3A//zhidao.baidu.com.jishu6.cn/java/%3fa=3.7122719435778 13分享举报
  • //可以启动一个线程来做时间计算//也可以用timer来实现定时 timer使用wait 我这里用sleep//关键不是用什么而是用线程来解决问题import java.util.Scanner;public class Test {public static void main(String[] args...
  • 1. 用Timer和TimerTask分析: 在实现时,Timer类可以调度任务,TimerTask则是通过在run()方法里实现具体任务。Timer实例可以调度多任务,它是线程安全的。当Timer的构造器被调用时,它创建了一个线程,这个线程可以...
  • 一是通过java.util.concurrent.DelayQueue实现;二是通过java.util.concurrent.ScheduledThreadPoolExecutor实现。1. java.util.concurrent.DelayQueue类DelayQueue是一个×××阻塞队列,只有在延迟期满时才能从中...
  • java实现定时删除过期文件(多线程,可以多添加其他路径) package com.company; import java.io.File; import java.util.Date; /* * 定时任务 删除 过期 文件 (多线程) * */ public...
  • Java线程启动后定时摧毁如何实现
  • java实现定时功能

    2016-05-10 15:05:00
    我们可以使用Timer和TimerTask类在java实现定时任务,详细说明如下:1、基础知识java.util.Timer一种线程设施,用于安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行。此类是线程安全的:多...
  • 主要是GUI界面获取用户设定,与当前时间比较,利用线程休眠实现类似定时器功能,每分钟检查一次,最终启动命令。第一次自己动手,遇到了很多麻烦,程序也只是一个思路,很原始,适合新手,希望继续学习。
  • 首先创建一个基本抽象类SchedThread,代码内容如下: view plaincopy to clipboardprint?...* 基于Java线程实现后台定时监控 <P> Created: Mar 26, 2008 10:08:43 </P><P> * <...
  • 实现功能: 执行3个线程到线程池,默认每个线程任务2秒执行一次.程序运行10秒后,修改所有线程中任务执行间隔为1秒,运行20秒后给所有线程中任务下停止命令,并停止所有线程池任务. 实体类: package top.thread.entity; ...
  • 1 package dingshirenwu;... 3 import java.util.Calendar; 4 import java.util.Date; 5 import java.util.Timer; 6 import java.util.TimerTask; 7 8 public class Test { 9 public...
  • 前几篇文章中分别介绍了单线程化线程池(newSingleThreadExecutor)可控最大并发数线程池(newFixedThreadPool)可回收缓存线程池(newCachedThreadPool)newScheduledThreadPool用于构造安排线程池,能够根据需要安排在...
  • 聊聊定时任务定时任务,顾名思义就是,定时去完成某项任务,例如指定某个时间点去做某件事情...因此,定时任务就是在后台启动一个线程定期定时的为你去执行相同的事情。在本篇文章中我们主要叨叨一下以一定的时间...
  • Java实现定时任务

    2017-10-15 18:16:35
    一、使用原始线程实现定时任务 二、使用Timer和TimerTask实现定时任务 三、使用ScheduledExecutorService实现定时任务
  • 一、概述在java实现定时执行任务的功能,主要用到两个类,Timer和TimerTask类。其中Timer是用来在一个后台线程按指定的计划来执行指定的任务。TimerTask一个抽象类,它的子类代表一个可以被Timer计划的任务,具体...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,338
精华内容 535
关键字:

java线程实现定时

java 订阅