Time in milliseconds.
timer
Description
This module provides functions related to time. Unless otherwise stated, time is always measured in milliseconds. All timer functions return immediately; the requested operations are performed asynchronously.
On success, the timer functions return {ok, TRef}, where TRef is a timer reference. A timer reference is an opaque term whose contents must not be changed, and which can be passed to cancel/1 to cancel the requested action.
The timeouts are not exact, but are at least as long as requested.
Creating timers using erlang:send_after/3 and erlang:start_timer/3 is more efficient than using the timers provided by this module. However, the timer module has been improved in OTP 25, making it more efficient and less susceptible to being overloaded. See the Timer Module section in the Efficiency Guide.
apply_after(Time, Function) -> {ok, TRef} | {error, Reason}OTP 27.0
Evaluates spawn(erlang, apply, [Function, []]) after Time milliseconds.
Returns {ok, TRef} or {error, Reason}.
apply_after(Time, Function, Arguments) ->
{ok, TRef} | {error, Reason}OTP 27.0
Types
Time = time()
Function = fun((...) -> term())
Arguments = [term()]
TRef = tref()
Reason = term()
Evaluates spawn(erlang, apply, [Function, Arguments]) after Time milliseconds.
Returns {ok, TRef} or {error, Reason}.
apply_after(Time, Module, Function, Arguments) ->
{ok, TRef} | {error, Reason}
Types
Time = time()
Module = module()
Function = atom()
Arguments = [term()]
TRef = tref()
Reason = term()
Evaluates spawn(Module, Function, Arguments) after Time milliseconds.
Returns {ok, TRef} or {error, Reason}.
apply_interval(Time, Function) -> {ok, TRef} | {error, Reason}OTP 27.0
Evaluates spawn(erlang, apply, [Function, []]) repeatedly at intervals of Time, irrespective of whether a previously spawned process has finished or not.
Returns {ok, TRef} or {error, Reason}.
apply_interval(Time, Function, Arguments) ->
{ok, TRef} | {error, Reason}OTP 27.0
Types
Time = time()
Function = fun((...) -> term())
Arguments = [term()]
TRef = tref()
Reason = term()
Evaluates spawn(erlang, apply, [Function, Arguments]) repeatedly at intervals of Time, irrespective of whether a previously spawned process has finished or not.
Returns {ok, TRef} or {error, Reason}.
apply_interval(Time, Module, Function, Arguments) ->
{ok, TRef} | {error, Reason}
Types
Time = time()
Module = module()
Function = atom()
Arguments = [term()]
TRef = tref()
Reason = term()
Evaluates spawn(Module, Function, Arguments) repeatedly at intervals of Time, irrespective of whether a previously spawned process has finished or not.
Warning
If the execution time of the spawned process is, on average, greater than the given Time, multiple such processes will run at the same time. With long execution times, short intervals, and many interval timers running, this may even lead to exceeding the number of allowed processes. As an extreme example, consider [timer:apply_interval(1, timer, sleep, [1000]) || _ <- lists:seq(1, 1000)], that is, 1,000 interval timers executing a process that takes 1s to complete, started in intervals of 1ms, which would result in 1,000,000 processes running at the same time, far more than a node started with default settings allows (see the System Limits section in the Efficiency Guide).
Returns {ok, TRef} or {error, Reason}.
apply_repeatedly(Time, Function) -> {ok, TRef} | {error, Reason}OTP 27.0
Evaluates spawn(erlang, apply, [Function, []]) repeatedly at intervals of Time, waiting for the spawned process to finish before starting the next.
Returns {ok, TRef} or {error, Reason}.
apply_repeatedly(Time, Function, Arguments) ->
{ok, TRef} | {error, Reason}OTP 27.0
Types
Time = time()
Function = fun((...) -> term())
Arguments = [term()]
TRef = tref()
Reason = term()
Evaluates spawn(erlang, apply, [Function, Arguments]) repeatedly at intervals of Time, waiting for the spawned process to finish before starting the next.
Returns {ok, TRef} or {error, Reason}.
apply_repeatedly(Time, Module, Function, Arguments) ->
{ok, TRef} | {error, Reason}OTP 26.0
Types
Time = time()
Module = module()
Function = atom()
Arguments = [term()]
TRef = tref()
Reason = term()
Evaluates spawn(Module, Function, Arguments) repeatedly at intervals of Time, waiting for the spawned process to finish before starting the next.
If the execution time of the spawned process is greater than the given Time, the next process is spawned immediately after the one currently running has finished. Assuming that execution times of the spawned processes performing the applies on average are smaller than Time, the amount of applies made over a large amount of time will be the same even if some individual execution times are larger than Time. The system will try to catch up as soon as possible. For example, if one apply takes 2.5*Time, the following two applies will be made immediately one after the other in sequence.
Returns {ok, TRef} or {error, Reason}.
cancel(TRef) -> {ok, cancel} | {error, Reason}
Cancels a previously requested timer. TRef is a unique timer reference returned by the timer function that requested the timer.
Returns {ok, cancel}, or {error, Reason} when TRef is not a timer reference.
exit_after(Time, Reason1) -> {ok, TRef} | {error, Reason2}
exit_after(Time, Target, Reason1) -> {ok, TRef} | {error, Reason2}
exit_after/2 is the same as exit_after(Time, self(), Reason1).
exit_after/3 sends an exit signal with reason Reason1 to Target, which can be a local process identifier or an registered name. Returns {ok, TRef} or {error, Reason2}.
hms(Hours, Minutes, Seconds) -> MilliSeconds
Returns the number of milliseconds in Hours + Minutes + Seconds.
hours(Hours) -> MilliSeconds
Returns the number of milliseconds in Hours.
kill_after(Time) -> {ok, TRef} | {error, Reason2}
kill_after(Time, Target) -> {ok, TRef} | {error, Reason2}
kill_after/1 is the same as exit_after(Time, self(), kill).
kill_after/2 is the same as exit_after(Time, Target, kill).
minutes(Minutes) -> MilliSeconds
Returns the number of milliseconds in Minutes.
now_diff(T2, T1) -> Tdiff
Calculates the time difference Tdiff = T2 - T1 in microseconds, where T1 and T2 are timestamp tuples on the same format as returned by erlang:timestamp/0 or os:timestamp/0.
seconds(Seconds) -> MilliSeconds
Returns the number of milliseconds in Seconds.
send_after(Time, Message) -> {ok, TRef} | {error, Reason}
send_after(Time, Destination, Message) ->
{ok, TRef} | {error, Reason}
- send_after/3
-
Evaluates Destination ! Message after Time milliseconds. (Destination can be a remote or local process identifier, a registered name or a tuple {RegName, Node} for a registered name on the node Node.)
Returns {ok, TRef} or {error, Reason}.
- send_after/2
-
Same as send_after(Time, self(), Message).
send_interval(Time, Message) -> {ok, TRef} | {error, Reason}
send_interval(Time, Destination, Message) ->
{ok, TRef} | {error, Reason}
- send_interval/3
-
Evaluates Destination ! Message repeatedly after Time milliseconds. (Destination can be a remote or local process identifier, a registered name or a tuple {RegName, Node} for a registered name on the node Node.)
Returns {ok, TRef} or {error, Reason}.
- send_interval/2
-
Same as send_interval(Time, self(), Message).
sleep(Time) -> ok
Types
Time = time() | infinity
Suspends the process calling this function for Time milliseconds and then returns ok, or suspends the process forever if Time is the atom infinity. Naturally, this function does not return immediately.
Note
Before OTP 25, timer:sleep/1 did not accept integer timeout values greater than 16#ffffffff, that is, 2^32-1. Since OTP 25, arbitrarily high integer values are accepted.
start() -> ok
Starts the timer server. Normally, the server does not need to be started explicitly. It is started dynamically when it is needed. This is useful during development, but in a target system the server should be started explicitly. Use configuration parameters for Kernel for this.
tc(Fun) -> {Time, Value}OTP R14B03
tc(Fun, Arguments) -> {Time, Value}OTP R14B
tc(Module, Function, Arguments) -> {Time, Value}
- tc/3
-
Calls function timer:tc(Module, Function, Arguments, microsecond).
- tc/2
-
Calls function timer:tc(Fun, Arguments, microsecond).
- tc/1
-
Calls function timer:tc(Fun, microsecond).
tc(Fun, TimeUnit) -> {Time, Value}OTP 26.0
tc(Fun, Arguments, TimeUnit) -> {Time, Value}OTP 26.0
tc(Module, Function, Arguments, TimeUnit) -> {Time, Value}OTP 26.0
Types
Module = module()
Function = atom()
Arguments = [term()]
TimeUnit = erlang:time_unit()
Time = integer()
In the specified TimeUnit
Value = term()
- tc/4
-
Evaluates apply(Module, Function, Arguments) and measures the elapsed real time as reported by erlang:monotonic_time/0.
Returns {Time, Value}, where Time is the elapsed real time in the specified TimeUnit, and Value is what is returned from the apply.
- tc/3
-
Evaluates apply(Fun, Arguments). Otherwise the same as tc/4.
- tc/2
-
Evaluates Fun(). Otherwise the same as tc/3.
Examples
Example 1
The following example shows how to print "Hello World!" in 5 seconds:
1> timer:apply_after(5000, io, format, ["~nHello World!~n", []]).
{ok,TRef}
Hello World!Example 2
The following example shows a process that is killed if it does not finish its task within a certain time limit:
Pid = spawn(Mod, Fun, Args),
%% If the process is not done in 10 seconds, kill it
{ok, TRef} = timer:kill_after(timer:seconds(10), Pid),
...
%% We changed our mind...
timer:cancel(TRef),
...
Notes
A timer can always be removed by calling cancel/1.
An interval timer created by evaluating any of the functions apply_interval/2, apply_interval/3, apply_interval/4, apply_repeatedly/2, apply_repeatedly/3 and apply_repeatedly/4 is automatically cancelled when the process that created it terminates.
An interval timer created by evaluating send_interval/2 or send_interval/3 is automatically cancelled when the destination process terminates.
A one-shot timer, that is, a timer created by evaluating any of the functions apply_after/2, apply_after/3, apply_after/4, send_after/2, send_after/3, exit_after/2, exit_after/3, kill_after/1, and kill_after/2 is removed only when it reaches its timeout, or if it is explicitly removed by a call to cancel/1.
The functions given to apply_after/2, apply_after/3, apply_interval/2, apply_interval/3, apply_repeatedly/2, and apply_repeatedly/3, or denoted by Module, Function and Arguments given to apply_after/4, apply_interval/4, and apply_repeatedly/4 are executed in a freshly spawned process, and therefore calls to self() in those functions will return the process identifier of this process, which is different from the process that called timer:apply_*.
Example
In the following example, a timer is set to execute a function after 1 second. The function performs a fictional task and then informs the process that set the timer about its completion, by sending it a done message.
The code below, which uses self/0 _inside_ the timed function, does not work as intended. The task gets done, but the `done` message gets sent to the wrong process and is lost.
1> timer:apply_after(1000, fun() -> do_something(), self() ! done end). {ok,TRef} 2> receive done -> done after 5000 -> timeout end. %% ... 5s pass... timeout
The code below calls self() in the process which sets the timer and assigns it to a variable, which is then used in the function to send the done message to, and so works as intended.
1> Target = self(). <0.82.0> 2> timer:apply_after(1000, fun() -> do_something(), Target ! done end). {ok,TRef} 3> receive done -> done after 5000 -> timeout end. %% ... 1s passes... done
Another option is to pass the message target as a parameter to the function.
1> timer:apply_after(1000, fun(Target) -> do_something(), Target ! done end, [self()]). {ok,TRef} 2> receive done -> done after 5000 -> timeout end. %% ... 1s passes... done