精华内容
下载资源
问答
  • timerTask实现每天定时一段时间内执行定时任务,这个是自己写的代码,有些和我的项目有关,可以删掉,但是其主要的都在里面,我写了注释。
  • TimerTask 类 public abstract class TimerTask implements Runnable { /** * 控制访问timertask内部的锁 */ final Object lock = new Object(); /** * 初始状态为0,就是还没有被计划执行 */ in...

     

    TimerTask 类

    public abstract class TimerTask implements Runnable {
        /**
         * 控制访问timertask内部的锁
         */
        final Object lock = new Object();
    
        /**
         * 初始状态为0,就是还没有被计划执行
         */
        int state = VIRGIN;
    
        /**
         * 最初始化的状态
         */
        static final int VIRGIN = 0;
    
        /**
         * 已经被计划执行了
         */
        static final int SCHEDULED   = 1;
    
        /**
         * 正在被执行,反正没有被返回
         */
        static final int EXECUTED    = 2;
    
        /**
         * 已经被返回了,
         */
        static final int CANCELLED   = 3;
    
        /**
         * 下次将要被执行的时间
         */
        long nextExecutionTime;
    
        /**
         * 间隔多久执行任务
         */
        long period = 0;
    
        /**
         * 构造函数
         */
        protected TimerTask() {
        }
    
        /**
         * 会被子类实现,run的内容就是任务的内容
         */
        public abstract void run();
    
        /**
         * 执行返回,如果正在被执行,那么会等执行完毕,再返回
         */
        public boolean cancel() {
            synchronized(lock) {
                boolean result = (state == SCHEDULED);
                state = CANCELLED;
                return result;
            }
        }
    
        /**
         * 返回下一次要被执行的时间
         */
        public long scheduledExecutionTime() {
            synchronized(lock) {
                return (period < 0 ? nextExecutionTime + period
                                   : nextExecutionTime - period);
            }
        }
    }
    

    TaskQueue类源码

    class TaskQueue {
        /**
         * 优先级任务对列,队列初始化的长度为128,这个队列是一个最小堆
         * 最小堆就是父节点总是小于等于子节点,这里的大小是任务执行的时刻,任务执行的时刻
         * 最小的,放在根节点,就是按照先后顺序
         */
        private TimerTask[] queue = new TimerTask[128];
    
        /**
         * 优先级对列中的任务数
         */
        private int size = 0;
    
        /**
         * 返回size的值
         */
        int size() {
            return size;
        }
    
        /**
         * 向对列添加一个任务
         */
        void add(TimerTask task) {
            // 如果队列中任务数要满的时候,就扩展队列的长度为2倍
            if (size + 1 == queue.length)
                queue = Arrays.copyOf(queue, 2*queue.length);
    
            queue[++size] = task; //将任务添加到队列中
            fixUp(size); //在队列末尾插入一个任务后,要重新调整最小堆,以保证最小堆的大小顺序
        }
    
        /**
         * 返回最小堆中的根节点,最小的执行时间的任务
         */
        TimerTask getMin() {
            return queue[1];
        }
    
        /**
         * 根据下标i,返回任务
         */
        TimerTask get(int i) {
            return queue[i];
        }
    
        /**
         * 删除最小的任务(根节点),然后将队列末尾的那个值放在根节点处,再调整堆的顺序
         */
        void removeMin() {
            queue[1] = queue[size];
            queue[size--] = null; 
            fixDown(1);
        }
    
        /**
         * 直接删除第i个节点,然后将队列末尾的那个节点占据i节点位置,不调整堆的顺序
         */
        void quickRemove(int i) {
            assert i <= size;
    
            queue[i] = queue[size];
            queue[size--] = null;  
        }
    
        /**
         * 设置根节点的执行时间,然后重新调整堆的顺序
         */
        void rescheduleMin(long newTime) {
            queue[1].nextExecutionTime = newTime;
            fixDown(1);
        }
    
        /**
         * 判断任务数是否为0
         */
        boolean isEmpty() {
            return size==0;
        }
    
        /**
         * 将这个队列清空
         */
        void clear() {
            for (int i=1; i<=size; i++)
                queue[i] = null;
    
            size = 0;
        }
    
        /**
         * 将K节点从底向上调整堆的顺序
         */
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
                    break;
                TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
                k = j;
            }
        }
    
        /**
         * 从k节点从上向下调整堆顺序
         */
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size && j > 0) {
                if (j < size &&
                    queue[j].nextExecutionTime > queue[j+1].nextExecutionTime)
                    j++; // j indexes smallest kid
                if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)
                    break;
                TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
                k = j;
            }
        }
    
        /**
         * 调整一个堆的顺序
         */
        void heapify() {
            for (int i = size/2; i >= 1; i--)
                fixDown(i);
        }
    }
    

     最大堆 ,父节点的值总是大于等于子节点的值。

    一个节点的下标,比如 7>>1 就跑到了父节点,6也是。

    一个节点的下标,比如 1<<1,就跑到了左子节点2,然后2+1,就跑到了右子节点3。

    TimerThread类源码

    class TimerThread extends Thread {
        /**
         * true代表队列中已经没有任务了,false代表Timer对象的引用已经无效了
         */
        boolean newTasksMayBeScheduled = true;
    
        /**
         * 任务队列,最小堆
         */
        private TaskQueue queue;
    
        TimerThread(TaskQueue queue) { //构造方法
            this.queue = queue;
        }
    
        public void run() {
            try {
                mainLoop();
            } finally {
                // Someone killed this Thread, behave as if Timer cancelled
                synchronized(queue) {
                    newTasksMayBeScheduled = false;
                    queue.clear();  // Eliminate obsolete references
                }
            }
        }
    
        /**
         * The main timer loop.  (See class comment.)
         */
        private void mainLoop() {
            while (true) {
                try {
                    TimerTask task;
                    boolean taskFired;
                    synchronized(queue) {
                        // Wait for queue to become non-empty
                        while (queue.isEmpty() && newTasksMayBeScheduled)
                            queue.wait();
                        if (queue.isEmpty())
                            break; // Queue is empty and will forever remain; die
    
                        // Queue nonempty; look at first evt and do the right thing
                        long currentTime, executionTime;
                        task = queue.getMin();
                        synchronized(task.lock) {
                            if (task.state == TimerTask.CANCELLED) {
                                queue.removeMin();
                                continue;  // No action required, poll queue again
                            }
                            currentTime = System.currentTimeMillis();
                            executionTime = task.nextExecutionTime;
                            if (taskFired = (executionTime<=currentTime)) {
                                if (task.period == 0) { // Non-repeating, remove
                                    queue.removeMin();
                                    task.state = TimerTask.EXECUTED;
                                } else { // Repeating task, reschedule
                                    queue.rescheduleMin(
                                      task.period<0 ? currentTime   - task.period
                                                    : executionTime + task.period);
                                }
                            }
                        }
                        if (!taskFired) // Task hasn't yet fired; wait
                            queue.wait(executionTime - currentTime);
                    }
                    if (taskFired)  // Task fired; run it, holding no locks
                        task.run();
                } catch(InterruptedException e) {
                }
            }
        }
    }

     

     

     

    展开全文
  • 这是一个自动创建文件夹的定时任务,并且使用java代码直接操纵svn上传,无需手动操纵svn。内容仅供大家参考学习,本人不是高手,若有不足之处请大家见谅,并请大家提出宝贵意见,谢谢!
  • TimerTask 定时任务demo

    2019-09-28 01:27:02
    3 在不借助spring容器的情况下实现web项目的定时任务 4 */ 5 // 1. 创建一个执行定时任务的监听类 6 import java.util.Calendar; 7 import java.util.GregorianCalendar; 8 import java.util.Timer; 9 ...
     1 /*
     2 需求:
     3 在不借助spring容器的情况下实现web项目的定时任务
     4 */
     5 // 1. 创建一个执行定时任务的监听类
     6 import java.util.Calendar;
     7 import java.util.GregorianCalendar;
     8 import java.util.Timer;
     9 
    10 import javax.servlet.ServletContextEvent;
    11 import javax.servlet.ServletContextListener;
    12 
    13 import com.sgcc.service.PreDataService;
    14 
    15 public class TimeListener implements ServletContextListener {
    16     private static Timer timer;
    17     private static PreDataService task = new PreDataService();
    18 
    19     public void contextDestroyed(ServletContextEvent arg0) {
    20         if (timer != null) {
    21             timer.cancel();
    22         }
    23     }
    24 
    25     public void contextInitialized(ServletContextEvent arg0) {
    26         try {
    27             timer = new Timer(true);
    28             GregorianCalendar now = new GregorianCalendar();
    29             now.set(Calendar.HOUR_OF_DAY, 16);//
    30             now.set(Calendar.MINUTE, 52);    //
    31             now.set(Calendar.SECOND, 0);    //32             // task 要执行的对象,now.getTime() 系统当前时间  5000每隔5秒执行一次 如果是每天执行一次 设置为 1*1000*60*60*24
    33             timer.schedule(task, now.getTime(),5000);
    34         } catch (Exception e) {
    35             e.printStackTrace();
    36         }
    37     }
    38 }
    39 // 2. 创建执行任务的类
    40 public class PreDataService extends TimerTask {
    41 
    42     @Override
    43     public void run() {
    44                 // 调用需要处定时处理的相关方法
    45         //BaseDao baseDao = new BaseDao();
    46         //baseDao.saveCHELIANG();
    47         //baseDao.savePAICHE();
    48     }
    49 
    50 }
    51     
    TimerTask 定时demo
    1 <!-- 在web容器中添加一个listener 指定要执行的类即可 -->
    2 <listener>
    3     <listener-class>com.sgcc.timeUtil.TimeListener</listener-class>
    4 </listener>
    Web容器配置

     

    用到的类:java.util.TimerTask

    转载于:https://www.cnblogs.com/ejokovic/p/5166918.html

    展开全文
  • 利用jdk中的timer和timertask来实现,每天定时执行的任务
  • TimerTask定时任务 1. 介绍 java.util.TimerTask是一个被Timer类执行的任务。继承Runnable接口 2. 类变量 有下面四种状态: int state = VIRGIN; static final int VIRGIN = 0; static final int SCHEDULED = 1...

    TimerTask定时任务

    1. 介绍

    java.util.TimerTask是一个被Timer类执行的任务。继承Runnable接口

    2. 类变量

    有下面四种状态:

        int state = VIRGIN;
    
        static final int VIRGIN = 0;
    
        static final int SCHEDULED   = 1;
    
        static final int EXECUTED    = 2;
    
        static final int CANCELLED   = 3;
    

    VIRGIN:初始化状态,任务还没有被执行

    SCHEDULED:任务已经计划执行(如果不是一个重复执行的任务,它就还没有被执行过)

    EXECUTED:非重复性任务已经被执行了(或者正在执行),并且没有被取消

    CANCELLED:任务已经被取消(调用TimerTask.cancel)

    lock:控制访问TimerTask内部的锁

     final Object lock = new Object();
    

    nextExecutionTime:下一次任务执行的时间,如果是重复性任务,会在每一个任务执行前更新

    long nextExecutionTime;
    

    period:重复性任务的周期时间,一个正值表明是固定频率fixed-rate执行,负值表明固定延迟fixed-delay执行,0表示非重复性任务。固定频率与固定延迟区别会在Timer定时器中看着代码讲

     long period = 0;
    

    3.成员方法

    构造方法:

      protected TimerTask() {
       }
    

    run():timerTask需要执行的具体操作,需要重写

    public abstract void run();
    

    cancel():取消任务,如果任务正在执行中,会执行完。

     public boolean cancel() {
            synchronized(lock) {
                boolean result = (state == SCHEDULED);
                state = CANCELLED;
                return result;
            }
        }
    

    scheduledExecutionTime():最近一次执行时间

    public long scheduledExecutionTime() {
            synchronized(lock) {
                return (period < 0 ? nextExecutionTime + period
                                   : nextExecutionTime - period);
            }
        }
    

    实时内容请关注微信公众号,公众号与博客同时更新:程序员星星
    实时内容请关注微信公众号,公众号与博客同时更新

    展开全文
  • import java.util.Timer; import java.util.TimerTask;... * TimerTask 定时任务定时任务是jdk自己提供的定时任务 需要Timer和TimerTask结合使用 * * 首先Timer在初始化的时候,Timer中的TimerThread线程对象立...
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class test2 {
    
        /**
         * TimerTask 定时任务  该定时任务是jdk自己提供的定时任务 需要Timer和TimerTask结合使用
         *
         * 首先Timer在初始化的时候,Timer中的TimerThread线程对象立即启动线程,如果没有线程,则处于等待状态
         * 当调用schedule方法时,添加了一个TimerTask  而TimerTask实现了Runnable,存在run方法,故而唤醒线程继续执行下去
         *
         * 注意:在TimerTask任务执行完毕后,虚拟机不会马上关闭销毁线程,我们可以调用System.gc()方法提醒虚拟机销毁无用的线程
         *
         */
        public static void main(String[] args) {
            Timer timer = new Timer();
            timer.schedule(new Task(),1000);
            System.out.println("242242424");
    
        }
    }
    
    
    class Task extends TimerTask{
    
        @Override
        public void run() {
            System.out.println("task1执行");
            System.gc();
        }
    }
    
    
    展开全文
  • 一. 简介 Timer是java自带的一种... 指定的任务定义可以通过TimerTask实现,通过继承TimerTaskTimerTask的子类代表一个可以被Timer计划的任务。 这里可以通过Timer类将定时器线程设置为用户线程和守护线程,...
  • TimerTask实现了Runnable接口,作为定时执行的任务载体。 >使用细节 每个 Timer 对象相对应的是单个后台线程,用于顺序地执行所有计时器任务。 提前:当计划时间早于当前时间,则任务立即被运行。 ...
  • Timer和TimerTask可以做为实现线程的第三种方式,前两中方式...可安排任务执行一次,或者定期重复执行,可以看成一个定时器,可以调度TimerTaskTimerTask是一个抽象类,实现了Runnable接口,所以具备了多线程的能力。
  • 关于TimerTask定时任务

    2018-12-10 15:41:00
    TimerTask不是由spring管理的,所以你TimerTask内部的service也无法自动注入,2种解决办法,1、TimerTask交由spring管理;2、通过applicationContext.getBean()获取service. 我这里采取了项目启动时,使用listenr...
  • public class PushMsgAPP extends TimerTask{ @Override public void run() { // TODO Auto-generated method stub System.out.println("---开始推送通知到APP---"); ResupplyPayAccount...
  • android开发中经常会遇到定时器需求(比如两秒之后销毁Dialog),实现方法也有很多种,今天就介绍一种很好用的Timer...2.TimerTask一个抽象类,它的子类代表一个可以被Timer计划的任务。 3.Timer.schedule的意思是时
  • 来实现,但是一些小型的任务其实完全利用Timer与TimerTask定时执行,Timer与TimerTask组合跟Thread与Runnable的区别在于,Timer与TimerTask是纯粹的单线程定时执行任务的计时器,相当于Thread与Runnable配合Thread....
  • TimerTask定时执行任务

    2018-08-27 11:12:31
    timer的是单线程模式,执行中出现异常就会终止线程,其他任务也得不到执行。在jdk1.5之后出现ScheduledThreadPoolExecutor可以更好的替代timer.... ...使用javaUtil的TimerTask实现每天1点定时执行任...
  • 这种方式是纯粹的java代码,需要继承timerTask接口并重写run方法,创建这个类的时候就会调用run方法。 基本的使用逻辑是: 把自己需要处理的业务逻辑放在自己写的这个继承了timerTask的类中,然后new一个timer并...
  • 定时任务 ![图片说明](https://img-ask.csdn.net/upload/201710/23/1508728254_52174.png) 方法调用 ![图片说明](https://img-ask.csdn.net/upload/201710/23/1508728266_302667.png) 大家帮忙看一下,问题出在哪里
  • java定时任务测试 继承TimerTask

    千次阅读 2018-08-09 14:44:49
    首先,介绍Java定时器(java.util.Timer)有定时执行计划任务的功能,通过设定定时器的间隔时间,会自动在此间隔时间后执行预先安排好的任务(java.util. TimerTask) 如: 每隔一个小时执行任务 timer.schedule...
  • JavaWeb Timer&TimerTask 定时任务

    千次阅读 2014-06-12 16:10:59
    JavaWeb 在程序启动时,定时执行计划任务
  • 主要介绍了Spring整合TimerTask实现定时任务调度的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,880
精华内容 5,952
关键字:

timertask定时任务