1. Hr Task Timer 1 2 72
2. Hr Task Timer 1 2 7/8
3. Hr Task Timer 1 2 75
4. Hr Task Timer 1 2 700

Allows you to countdown time from 1 hour 7 min to zero. Easy to adjust, pause, restart or reset. 1 hour 7 minute equal 4020000 Milliseconds 1 hour 7 minute equal 4020 Seconds 1 hour 7 minute is about 67 Minutes. Popular Preset Timers. 1 min 5 min 10 min 15 min 30 min 45 min 1 hour 2 hour. Timer(TimerCallback) Initializes a new instance of the Timer class with an infinite period and an infinite due time, using the newly created Timer object as the state object. Timer(TimerCallback, Object, Int32, Int32) Initializes a new instance of the Timer class, using a 32-bit signed integer to specify the time interval. Timer(TimerCallback, Object, Int64, Int64).

1. Java Timer class is thread safe and multiple threads can share a single Timer object without need for external synchronization. Timer class uses java.util.TaskQueue to add tasks at given regular interval and at any time there can be only one thread running the TimerTask, for example if you are creating a Timer to run every 10 seconds but single thread execution takes 20 seconds, then Timer.
2. Generally you run a scheduled task that has a finite run time and then the task exits. I don't understand what sort of task you would have that would start a new instance every hour but never exit. If it is a task that never exits, then you need to build your own timer into the task. That is beyond the scope of the task scheduler.

Source code:Lib/sched.py

The sched module defines a class which implements a general purpose eventscheduler:

The scheduler class defines a generic interface to scheduling events.It needs two functions to actually deal with the “outside world” — timefuncshould be callable without arguments, and return a number (the “time”, in anyunits whatsoever). The delayfunc function should be callable with oneargument, compatible with the output of timefunc, and should delay that manytime units. delayfunc will also be called with the argument 0 after eachevent is run to allow other threads an opportunity to run in multi-threadedapplications.

Example:

In multi-threaded environments, the scheduler class has limitationswith respect to thread-safety, inability to insert a new task beforethe one currently pending in a running scheduler, and holding up the mainthread until the event queue is empty. Instead, the preferred approachis to use the threading.Timer class instead.

Example:

8.8.1. Scheduler Objects¶

scheduler instances have the following methods and attributes:

Schedule a new event. The time argument should be a numeric type compatiblewith the return value of the timefunc function passed to the constructor.Events scheduled for the same time will be executed in the order of theirpriority. A lower number represents a higher priority.

Executing the event means executing action(*argument). argument must be asequence holding the parameters for action.

Return value is an event which may be used for later cancellation of the event(see cancel()).

Schedule an event for delay more time units. Other than the relative time, theother arguments, the effect and the return value are the same as those forenterabs().

Remove the event from the queue. If event is not an event currently in thequeue, this method will raise a ValueError.

Return true if the event queue is empty.

Run all scheduled events. This function will wait (using the delayfunc()function passed to the constructor) for the next event, then execute it and soon until there are no more scheduled events.

Either action or delayfunc can raise an exception. In either case, thescheduler will maintain a consistent state and propagate the exception. If anexception is raised by action, the event will not be attempted in future callsto run().

If a sequence of events takes longer to run than the time available before thenext event, the scheduler will simply fall behind. No events will be dropped;the calling code is responsible for canceling events which are no longerpertinent.

Read-only attribute returning a list of upcoming events in the order theywill be run. Each event is shown as a named tuple with thefollowing fields: time, priority, action, argument.

Over the week-end I created the TaskTimer class that allows to execute code on timer in an async method:

Source code: https://github.com/ikriv/tasktimer

Nuget package: https://www.nuget.org/packages/TaskTimer/1.0.0

Motivation

To my astonishment, I have found that .NET Task Library does not (seem to) have support for executing a task on timer, similar to Observable.Interval(). I needed to execute an activity every second in my async method, and the suggestions I found on StackOverflow were quite awful: from using Task.Delay() to using a dedicated thread and Thread.Sleep().

Task.Delay() is good enough in many cases, but it has a problem. Consider this code:

Hr Task Timer 1 2 72

One execution of the loop takes 1300ms on average, instead of 1000ms we wanted. So, on every execution we will accumulate an additional delay of 300ms. If DoSomething() takes different time from iteration to iteration, our activity will not only be late, but it will also be irregular. One could, of course, use real-time clock to adjust the delay after every execution, but this is quite laborious and hard to encapsulate.

Using TaskTimer

Browser for “TaskTimer” package on NuGet and add it to your project. Alternatively, you can get the code from GitHub. The code requires .NET 4.5 or above.

You will need to choose the timer period, and the initial delay, or absolute start time:

The returned object is a disposable enumberable. You must call Dispose() on it to properly disposer of the underlying timer object. The enumerable iterates over an infinite series of tasks. Task number N becomes completed after the timer ticks N times. The enumerable can be enumerated only once.

Hr Task Timer 1 2 7/8

Avoiding infinite loop

Hr Task Timer 1 2 75

The enumerable returned by the timer is infinite, so you cannot get all the task at once.

Hr Task Timer 1 2 700

You can use foreach on the timer, but that would be an infinite loop:

If you know the number of iterations in advance, use Take() method:

If you don’t, you can use a cancellation token:

About Disposable Enumerable

I initially implemented the timer sequence as generator method using the yield keyword. You can see this in the GitHub history:

The trouble with this approach was that calling the Start() method did not actually start the timer: the timer would be started only when one begins to iterate over it. Furthermore, each iteration will create a new timer. I found this too confusing. I had enough trouble understanding similar behavior in observables to inflict this on the users of my own class.

So, I decided to switch to a schema where the timer gets started immediately upon calling of the Start() method. In reactive terms, TaskTimer is a hot observable. To stop the timer, one needs to dispose the return value of the Start() method, hence the disposable enumerable. To use the timer properly, one should put a foreach loop inside a using block like in the examples, above.

Also, it is only possible to iterate over the timer once. The following will not work:

It should be possible to implement a timer with multiple iteration semantics, but I decided it was not worth the complexity.

Conclusion

It’s a shame Task Library does not provide timer object out of the box. I hope I was able to fill the gap, at least to some extent. In the process I ran into interesting problems with the way IEnumerable, IEnumerator and IDisposable intersect, this is a fascinating world. I hope you do enjoy the result!