How can I configure the time zone for a Spring based [@Scheduled][1] cron job? 


**Background:**

I have a job that executes once a day, say 2 PM, using Spring&#39;s `@Scheduled` annotation:

    @Scheduled(cron = &quot;0 0 14 * * *&quot;)
    public void execute() {
        // do scheduled job
    }


The problem is that 2 PM differs between different servers, because Spring uses on `TimeZone.getDefault()` [internally][2]. Moreover, the [JavaDoc][3] of `TimeZone.getDefault()`&#160;states that:

&gt; Gets the default TimeZone for this host. The source of the default TimeZone may vary with implementation.

In other words, the time zone is not determined. It may depend on JVM implementation, server time zone configuration, server location, and / or other unknown factors. Consequently, the cron job triggers on different times on different servers, unless there is a way to explicitly set which time zone that should be used?

I am using Spring 3.2.2.

---
**Update**

As of Spring 4, Spring Jira issue [SPR-10456][4] has been resolved. Consequently, the `@Scheduled` annotation has a new [zone][5] attribute for exactly this purpose.


  [1]: http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/scheduling.html#scheduling-annotation-support-scheduled
  [2]: https://github.com/SpringSource/spring-framework/blob/3.2.x/spring-context/src/main/java/org/springframework/scheduling/support/CronSequenceGenerator.java#L81
  [3]: http://docs.oracle.com/javase/7/docs/api/java/util/TimeZone.html#getDefault()
  [4]: https://jira.spring.io/browse/SPR-10456
  [5]: http://docs.spring.io/spring-framework/docs/4.0.x/javadoc-api/org/springframework/scheduling/annotation/Scheduled.html#zone--

Provide time zone to Spring @Scheduled?

I&#39;m reading the [Spring 3.0 doc][1]s regarding scheduling. I&#39;m leaning towards Spring&#39;s JobDetailBean for Quartz. However, the **@Scheduled** annotation has captured my eye. It appears this is another way of scheduling task using the Spring Framework. Based on the docs, Spring provides three way of scheduling:

 1. @Scheduled
 2. Via Quartz
 3. Via JDK Timer

I have no interest in the JDK Timer. Why should I choose @Scheduled over Quartz? (When I mention Quartz I mean using Spring&#39;s bean wrapper for Quartz).

Let&#39;s say my use case is complex enough that I will be communicating to a third-party web service to import and export data at specified intervals.

  [1]: http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/scheduling.html

Spring Scheduling: @Scheduled vs Quartz

In Linux, supposing a thread&#39;s pid is [pid], from the directory /proc/[pid] we can get many useful information. For example, these proc files, /proc/[pid]/status,/proc/[pid]/stat and /proc/[pid]/schedstat are all useful. But how can I get the CPU core number that a thread is running in? If a thread is in sleep state, how can I know which core it will run after it is scheduled again?

BTW, is there a way to dump the process(thread) list of running and sleeping tasks for each CPU core?

How can I see which CPU core a thread is running in?

A [Google search][1] turned up software that performs the same functions as cron, but nothing built into Windows.

I&#39;m running Windows XP Professional, but advice for any version of Windows would be potentially helpful to someone.

Is there also a way to invoke this feature (which based on answers is called the Task Scheduler) programatically or via the command line?

  [1]: http://www.google.com/search?ie=UTF-8&amp;oe=UTF-8&amp;sourceid=navclient&amp;gfns=1&amp;q=windows+cron


What is the Windows version of cron?

I have code where I schedule a task using `java.util.Timer`. I was looking around and saw `ExecutorService` can do the same. So this question here, have you used `Timer` and `ExecutorService` to schedule tasks, what is the benefit of one using over another?

Also wanted to check if anyone had used the `Timer` class and ran into any issues which the `ExecutorService` solved for them.

Java Timer vs ExecutorService?

Sometimes whenever I write a program in Linux and it crashes due to a bug of some sort, it will become an uninterruptible process and continue running forever until I restart my computer (even if I log out).  My questions are:

 - What causes a process to become uninterruptible?
 - How do I stop that from happening?
 - This is probably a dumb question, but is there any way to interrupt it without restarting my computer?

What is an uninterruptible process?

Is there some cron like library that would let me schedule some function to be ran at certain time (15:30 for example, not x hours from now etc)? If there isn&#39;t this kind of library how this should be implemented? Should I just set callback to be called every second and check the time and start jobs scheduled for the time or what?

Is there a job scheduler library for node.js?

When using the Spring 3.0 capability to annotate a scheduled task, I would like to set the `fixedDelay` as parameter from my configuration file, instead of hard-wiring it into my task class, like currently...

	@Scheduled(fixedDelay = 5000)
	public void readLog() {
            ...
	}

Unfortunately it seems that with the means of the Spring Expression Language (SpEL) `@Value` returns a String object which in turn is not able to be auto-boxed to a long value as required by the `fixedDelay` parameter.

How to parameterize @Scheduled(fixedDelay) with Spring 3.0 expression language?

I have a service written in C# (.NET 1.1) and want it to perform some cleanup actions at midnight every night. I have to keep all code contained within the service, so what&#39;s the easiest way to accomplish this? Use of `Thread.Sleep()` and checking for the time rolling over?

How might I schedule a C# Windows Service to perform a task daily?

I read that it&#39;s supposedly possible to change the I/O scheduler for a particular device on a running kernel by writing to /sys/block/[disk]/queue/scheduler.  For example I can see on my system:

    anon@anon:~$ cat /sys/block/sda/queue/scheduler 
    noop anticipatory deadline [cfq] 

that the default is the completely fair queuing scheduler.  What I&#39;m wondering is if there is any use in including all four schedulers in my custom kernel.  It would seem that there&#39;s not much point in having more than one scheduler compiled in unless the kernel is smart enough to select the correct scheduler for the correct hardware, specifically the &#39;noop&#39; scheduler for flash based drives and one of the others for a traditional hard drive.

Is this the case?

Selecting a Linux I/O Scheduler

I would like to run a job through cron that will be executed every second Tuesday at given time of day. For every Tuesday is easy:

    0 6 * * Tue

But how to make it on &quot;every second Tuesday&quot; (or if you prefer - every second week)?
I would not like to implement any logic in the script it self, but keep the definition only in cron.

How to instruct cron to execute a job every second week?

I use ScheduledExecutorService to execute a method periodically.

p-code:

    ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
    ScheduledFuture&lt;?&gt; handle =
    	    scheduler.scheduleWithFixedDelay(new Runnable() {
    	         public void run() { 
    	             //Do business logic, may Exception occurs
    	         }
    	    }, 1, 10, TimeUnit.SECONDS);


My question:

How to continue the scheduler, if `run()` throws Exception? 
Should I try-catch all Exception in method `run()`? Or any built-in callback method to handle the Exception? Thanks!


ScheduledExecutorService Exception handling

Is there any way in Linux to assign one CPU core to a particular given process and there should not be any other processes or interrupt handlers to be scheduled on this core?

I have read about process affinity in Linux **Binding Processes to CPUs using the taskset utility** but that&#39;s not solving my problem because **it just try to affine the given process to that core but it is possible that other processes may be scheduled on this core** and this is what I want to avoid.

Should we change the kernel code for scheduling?

Whole one core dedicated to single process

I recently started to learn how the CPU and the operating system works, and I am a bit confused about the operation of a single-CPU machine with an operating system that provides multitasking.

Supposing my machine has a single CPU, this would mean that, at any given time, only one process could be running.

Now, I can only assume that the scheduler used by the operating system to control the access to the precious CPU time is also a process.

Thus, in this machine, either the user process or the scheduling system process is running at any given point in time, but not both.

So here&#39;s a question: 

Once the scheduler gives up control of the CPU to another process, how can it regain CPU time to run itself again to do its scheduling work? I mean, if any given process currently running does not yield the CPU, how could the scheduler itself ever run again and ensure proper multitasking?

So far, I had been thinking, well, if the user process requests an I/O operation through a system call, then in the system call we could ensure the scheduler is allocated some CPU time again. But I am not even sure if this works in this way.

On the other hand, if the user process in question were inherently CPU-bound, then, from this point of view, it could run forever, never letting other processes, not even the scheduler run again.

Supposing time-sliced scheduling, I have no idea how the scheduler could slice the time for the execution of another process when it is not even running?

I would really appreciate any insight or references that you can provide in this regard.

How does the OS scheduler regain control of CPU?

Does anybody know of a way to lock down individual threads within a Java process to specific CPU cores (on Linux)? I&#39;ve done this in C, but can&#39;t find how to do this in Java. My instincts are that this will require a JNI call, but I was hoping someone here might have some insight or might have done it before.

Thanks!

Java thread affinity

## Situation

I have a Runnable. I have a class that schedules this Runnable for execution using a ScheduledExecutorService with [scheduleWithFixedDelay](http://download.oracle.com/javase/1,5.0/docs/api/java/util/concurrent/ScheduledExecutorService.html#scheduleWithFixedDelay%28java.lang.Runnable,%20long,%20long,%20java.util.concurrent.TimeUnit%29).

## Goal

I want to alter this class to schedule the Runnable for fixed delay execution _either_ indefinitely, _or_ until it has been run a certain number of times, depending on some parameter that is passed in to the constructor.

If possible, I would like to use the same Runnable, as it is conceptually the same thing that should be &quot;run&quot;.

## Possible approaches

### Approach #1

Have two Runnables, one that cancels the schedule after a number of executions (which it keeps a count of) and one that doesn&#39;t:

    public class MyClass{
        private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();

        public enum Mode{
            INDEFINITE, FIXED_NO_OF_TIMES
        }

        public MyClass(Mode mode){
            if(mode == Mode.INDEFINITE){
                scheduler.scheduleWithFixedDelay(new DoSomethingTask(), 0, 100, TimeUnit.MILLISECONDS);
            }else if(mode == Mode.FIXED_NO_OF_TIMES){
                scheduler.scheduleWithFixedDelay(new DoSomethingNTimesTask(), 0, 100, TimeUnit.MILLISECONDS);
            }
        }
        
        private class DoSomethingTask implements Runnable{
            @Override
            public void run(){
                doSomething();
            }
        }
        
        private class DoSomethingNTimesTask implements Runnable{
            private int count = 0;
    
            @Override
            public void run(){
                doSomething();
                count++;
                if(count &gt; 42){
                    // Cancel the scheduling.
                    // Can you do this inside the run method, presumably using
                    // the Future returned by the schedule method? Is it a good idea?
                }
            }
        }
        
        private void doSomething(){
            // do something
        }
    }

I would rather just have one Runnable for the execution of the doSomething method. Tying the scheduling to the Runnable feels wrong. What do you think about this?

### Approach #2

Have a single Runnable for the execution of the code that we want to run periodically. Have a separate scheduled runnable that checks how many times the first Runnable has run and cancels when it gets to a certain amount. This may not be accurate, as it would be asynchronous. It feels a bit cumbersome. What do you think about this?

### Approach #3

Extend ScheduledExecutorService and add a method &quot;scheduleWithFixedDelayNTimes&quot;. Perhaps such a class already exists? Currently, I&#39;m using `Executors.newSingleThreadScheduledExecutor();` to get my ScheduledExecutorService instance. I would presumably have to implement similar functionality to instantiate the extended ScheduledExecutorService. This could be tricky. What do you think about this?

### No scheduler approach [Edit]

I could not use a scheduler. I could instead have something like:

    for(int i = 0; i &lt; numTimesToRun; i++){
        doSomething();
        Thread.sleep(delay);
    }

And run that in some thread. What do you think of that? You could potentially still use the runnable and call the run method directly.

---

Any suggestions welcome. I&#39;m looking for a debate to find the &quot;best practice&quot; way of achieving my goal.

How to stop a Runnable scheduled for repeated execution after a certain number of executions

I have a webpage hosted on a Windows box that I need to assure gets loaded at least once/day. My current plan is to create a scheduled task that opens Internet Explorer and hits the URL:

    &quot;C:\Program Files\Internet Explorer\iexplore.exe&quot; myurl.com/script_to_run_daily.aspx

This was simple to setup and works fine, but it strikes me as a hack because Internet Explorer actually has to open and hit this URL. I don&#39;t need any input back from this page, it simply stores cached data in files when it&#39;s hit.

Is there a slicker way of doing this? In case it matters, this is a VB.net site.

Thanks in advance!

All Scheduling Solutions on Gang of Coders

Total of 17 Scheduling Solutions