Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
timer(3)		   Erlang Module Definition		      timer(3)

NAME
       timer - Timer functions.

DESCRIPTION
       This module provides useful functions related to	time. Unless otherwise
       stated, time is always measured in milliseconds.	 All  timer  functions
       return immediately, regardless of work done by another process.

       Successful  evaluations	of the timer functions give return values con-
       taining a timer reference, denoted TRef.	By  using  cancel/1,  the  re-
       turned  reference can be	used to	cancel any requested action. A TRef is
       an Erlang term, which contents must not be changed.

       The time-outs are not exact, but	are at least as	long as	requested.

DATA TYPES
       time() =	integer() >= 0

	      Time in milliseconds.

       tref()

	      A	timer reference.

EXPORTS
       apply_after(Time, Module, Function, Arguments) ->
		      {ok, TRef} | {error, Reason}

	      Types:

		 Time =	time()
		 Module	= module()
		 Function = atom()
		 Arguments = [term()]
		 TRef =	tref()
		 Reason	= term()

	      Evaluates	apply(Module, Function,	 Arguments)  after  Time  mil-
	      liseconds.

	      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	 apply(Module,	Function, Arguments) repeatedly	at in-
	      tervals of Time.

	      Returns {ok, TRef} or {error, Reason}.

       cancel(TRef) -> {ok, cancel} | {error, Reason}

	      Types:

		 TRef =	tref()
		 Reason	= term()

	      Cancels a	previously requested time-out. TRef is a unique	 timer
	      reference	returned by the	related	timer function.

	      Returns  {ok,  cancel},  or  {error,  Reason} when TRef is not a
	      timer reference.

       exit_after(Time,	Reason1) -> {ok, TRef} | {error, Reason2}

       exit_after(Time,	Pid, Reason1) -> {ok, TRef} | {error, Reason2}

	      Types:

		 Time =	time()
		 Pid = pid() | (RegName	:: atom())
		 TRef =	tref()
		 Reason1 = Reason2 = term()

	      exit_after/2 is the same as exit_after(Time, self(), Reason1).

	      exit_after/3 sends an exit signal	with  reason  Reason1  to  pid
	      Pid. Returns {ok,	TRef} or {error, Reason2}.

       hms(Hours, Minutes, Seconds) -> MilliSeconds

	      Types:

		 Hours = Minutes = Seconds = MilliSeconds = integer() >= 0

	      Returns the number of milliseconds in Hours + Minutes + Seconds.

       hours(Hours) -> MilliSeconds

	      Types:

		 Hours = MilliSeconds =	integer() >= 0

	      Returns the number of milliseconds in Hours.

       kill_after(Time)	-> {ok,	TRef} |	{error,	Reason2}

       kill_after(Time,	Pid) ->	{ok, TRef} | {error, Reason2}

	      Types:

		 Time =	time()
		 Pid = pid() | (RegName	:: atom())
		 TRef =	tref()
		 Reason2 = term()

	      kill_after/1 is the same as exit_after(Time, self(), kill).

	      kill_after/2 is the same as exit_after(Time, Pid,	kill).

       minutes(Minutes)	-> MilliSeconds

	      Types:

		 Minutes = MilliSeconds	= integer() >= 0

	      Returns the number of milliseconds in Minutes.

       now_diff(T2, T1)	-> Tdiff

	      Types:

		 T1 = T2 = erlang:timestamp()
		 Tdiff = integer()
		   In microseconds

	      Calculates  the time difference Tdiff = T2 - T1 in microseconds,
	      where T1 and T2 are time-stamp tuples on the same	format as  re-
	      turned from erlang:timestamp/0 or	os:timestamp/0.

       seconds(Seconds)	-> MilliSeconds

	      Types:

		 Seconds = MilliSeconds	= integer() >= 0

	      Returns the number of milliseconds in Seconds.

       send_after(Time,	Message) -> {ok, TRef} | {error, Reason}

       send_after(Time,	Pid, Message) -> {ok, TRef} | {error, Reason}

	      Types:

		 Time =	time()
		 Pid = pid() | (RegName	:: atom())
		 Message = term()
		 TRef =	tref()
		 Reason	= term()

		send_after/3:
		  Evaluates  Pid  !  Message after Time	milliseconds. (Pid can
		  also be an atom of a registered name.)

		  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, Pid,	Message) -> {ok, TRef} | {error, Reason}

	      Types:

		 Time =	time()
		 Pid = pid() | (RegName	:: atom())
		 Message = term()
		 TRef =	tref()
		 Reason	= term()

		send_interval/3:
		  Evaluates Pid	! Message repeatedly after Time	 milliseconds.
		  (Pid can also	be an atom of a	registered name.)

		  Returns {ok, TRef} or	{error,	Reason}.

		send_interval/2:
		  Same as send_interval(Time, self(), Message).

       sleep(Time) -> ok

	      Types:

		 Time =	timeout()

	      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 im-
	      mediately.

       start() -> ok

	      Starts the timer server. Normally, the server does not  need  to
	      be  started  explicitly.	It  is	started	 dynamically  if it is
	      needed. This is useful during development, but in	a target  sys-
	      tem  the	server	is to be started explicitly. Use configuration
	      parameters for Kernel for	this.

       tc(Fun) -> {Time, Value}

       tc(Fun, Arguments) -> {Time, Value}

       tc(Module, Function, Arguments) -> {Time, Value}

	      Types:

		 Module	= module()
		 Function = atom()
		 Arguments = [term()]
		 Time =	integer()
		   In microseconds
		 Value = term()

		tc/3:
		  Evaluates apply(Module, Function,  Arguments)	 and  measures
		  the	elapsed	  real	 time	as  reported  by  erlang:mono-
		  tonic_time/0.

		  Returns {Time, Value}, where Time is the elapsed  real  time
		  in  microseconds, and	Value is what is returned from the ap-
		  ply.

		tc/2:
		  Evaluates apply(Fun, Arguments). Otherwise the same as tc/3.

		tc/1:
		  Evaluates Fun(). Otherwise the same as tc/2.

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 performing	a certain action,  and
       if  this	action is not completed	within a certain limit,	the process is
       killed:

       Pid = spawn(mod,	fun, [foo, bar]),
       %% If pid is not	finished in 10 seconds,	kill him
       {ok, R} = timer:kill_after(timer:seconds(10), Pid),
       %% We change our	mind...
       timer:cancel(R),

NOTES
       A timer can always be removed by	calling	cancel/1.

       An interval timer, that is, a timer created by evaluating  any  of  the
       functions  apply_interval/4,  send_interval/3,  and  send_interval/2 is
       linked to the process to	which the timer	performs its task.

       A one-shot timer, that is, a timer created by  evaluating  any  of  the
       functions   apply_after/4,  send_after/3,  send_after/2,	 exit_after/3,
       exit_after/2, kill_after/2, and	kill_after/1  is  not  linked  to  any
       process.	 Hence,	such a timer is	removed	only when it reaches its time-
       out, or if it is	explicitly removed by a	call to	cancel/1.

Ericsson AB			  stdlib 3.8			      timer(3)

NAME | DESCRIPTION | DATA TYPES | EXPORTS | EXAMPLES | NOTES

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=timer&sektion=3&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help