Sleep: Difference between revisions

{{task|Basic language learning}}

Write a program that does the following in this order:

* Input an amount of time to sleep in whatever units are most natural for your language (milliseconds, seconds, ticks, etc.). This unit should be noted in comments or in a description.

* Sleep the main [[thread]] for the given amount of time.

* Print "Awake!"

* End.

 

=={{header|Ada}}==

The Ada delay statement takes an argument of type Duration, which is a real number counting the number of seconds to delay. Thus, 2.0 will delay 2.0 seconds, while 0.001 will delay 0.001 seconds.

 

with Ada.Float_Text_Io; use Ada.Float_Text_Io;

delay Duration(In_Val);

Put_Line("Awake!");

=={{header|AutoHotkey}}==

sleep, 2000 ; 2 seconds

TrayTip, awake, awake

 

=={{header|AutoIt}}==

$sleep_me=InputBox("Sleep", "Number of seconds to sleep", "10", "", -1, -1, 0, 0)

Dim $sleep_millisec=$sleep_me*1000

MsgBox(0,"Sleep","Sleeping for "&$sleep_me&" sec")

sleep ($sleep_millisec)

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

PRINT "Sleeping..."

SLEEP sec

"SLEEP" with no argument will sleep until a button is pressed on the keyboard (including modifier keys such as shift or control). Also, pressing a key while SLEEP is waiting for a specific amount of time (as above) will end the SLEEP.

 

 

Pressing a key will cut the pause short on the ZX Spectrum.

 

 

=={{header|Batch File}}==

 

{{works with|Windows NT|4}}

set /p Seconds=Enter the number of seconds to sleep:

set /a Seconds+=1

echo Sleeping ...

ping -n %Seconds% localhost >nul 2>&1

A similar trick can be used to wait a certain number of milliseconds. The <code>ping</code> utility includes a <code>/w</code> option which specifies the timeout to wait for a reply. This coupled with an unreachable address (where the full timeout will be needed) leads to the following:

 

{{works with|Windows 2000}}

set /p MilliSeconds=Enter the number of milliseconds to sleep:

echo Sleeping ...

ping -n 1 -w %MilliSeconds% 1.2.3.4 >nul 2>&1

 

Starting with Windows Vista there is a command-line utility to wait a number of seconds:

 

{{works with|Windows Vista}}

set /p Seconds=Enter the number of seconds to sleep:

echo Sleeping ...

timeout /t %Seconds% /nobreak >nul

 

=={{header|C}}==

The function <tt>sleep</tt> needs seconds, which are read from the standard input.

 

#include <unistd.h>

 

printf("Awake!\n");

return 0;

 

=={{header|C++}}==

 

#include <iostream>

 

cout << "Awake!" << endl;

return 0;

 

 

 

=={{header|Clojure}}==

(println "Sleeping...")

(Thread/sleep ms)

(println "Awake!"))

; call it

 

 

=={{header|Common Lisp}}==

(let ((seconds (read)))

(format t "Sleeping...~%")

(format t "Awake!~%")))

 

 

=={{header|D}}==

void main() {

 

=={{header|E}}==

 

So, the closest thing possible to the task description is to wait for the specified time to pass, then do whatever the next thing is.

 

stdout.println("Sleeping...")

timer.whenPast(timer.now() + milliseconds, fn {

nextThing()

})

 

=={{header|Eiffel}}==

<code lang="eiffel">sleep</code> takes an argument which declares the number of nanoseconds to suspend the thread's execution.

 

APPLICATION

inherit

print ("Awake!%N")

end

 

Output (sleeping 10 seconds):

<pre>

Enter a number of nanoseconds: 10000000000

Sleeping...

Awake!

 

Erlang doesn't really have such a thing as a main thread. However, sleeping any process can be done with the <tt>timer:sleep/1</tt> function:

io:format("Sleeping...~n"),

timer:sleep(1000), %% in milliseconds

 

It is to be noted that Erlang's sleep function is implemented in Erlang with a timeout on a <tt>receive</tt>, so you may sometimes encounter the following way of sleeping a process:

io:format("Sleeping...~n"),

receive

after 1000 -> ok %% in milliseconds

end,

 

which is the way it is implemented in the <tt>timer</tt> module.

 

=={{header|Factor}}==

 

: read-sleep ( -- )

"Sleeping..." print

sleep

 

=={{header|Forth}}==

." Sleeping..."

ms

=={{header|Fortran}}==

 

implicit none

end if

 

 

=={{header|Go}}==

 

import "time"

 

func main() {

fmt.Print("Sleeping…")

 

=={{header|Haskell}}==

 

main = do seconds <- readLn

putStrLn "Sleeping..."

threadDelay $ round $ seconds * 1000000

 

=={{header|HicEst}}==

WRITE(StatusBar) "Sleeping ... "

SYSTEM(WAIT = milliseconds)

 

 

repeat {

delay(1000 * s)

write("Awake!")

 

=={{header|J}}==

 

'''Solution''':

 

sleeping=: monad define

sleep y

smoutput 'Awake!'

 

'''Example''':

Sleeping...

 

=={{header|Java}}==

 

 

 

Generally, JavaScript in a web browser is event-loop based and (except for alert()) non-blocking. So, the closest thing possible to the task description is to do something once the specified time has passed.

 

 

=={{header|Logo}}==

to sleep :n

print [Sleeping...]

print [Awake.]

end

 

 

time = input('How many seconds would you like me to sleep for? ');

disp('Awake!');

 

 

 

 

{

 

 

 

 

=={{header|Objeck}}==

bundle Default {

class Test {

function : Main(args : System.String[]) ~ Nil {

if(args->Size() = 1) {

"Sleeping..."->PrintLine();

"Awake!"->PrintLine();

};

}

}

 

=={{header|OCaml}}==

 

let seconds = read_int ();;

print_endline "Sleeping...";;

Unix.sleep seconds;; (* number is integer in seconds *)

 

or

#directory "+threads";;

#load "threads.cma";;

print_endline "Sleeping...";;

Thread.delay seconds;; (* number is in seconds ... but accepts fractions *)

 

=={{header|Oz}}==

class TextFile from Open.file Open.text end

StdIn = {New TextFile init(name:stdin)}

{System.showInfo "Sleeping..."}

{Delay WaitTime} %% in milliseconds

 

=={{header|PARI/GP}}==

GP does not have threading built in and so cannot truly sleep; this is code for spin-idling.

print("Sleeping...");

alarm(s);

};

 

 

=={{header|Perl}}==

 

seconds:

print "Sleeping...\n";

sleep $seconds; # number is in seconds

 

microseconds and nanoseconds using the Time::HiRes module:

 

$microseconds = <>;

print "Sleeping...\n";

nanosleep $nanoseconds;

 

 

 

=={{header|PHP}}==

 

seconds:

echo "Sleeping...\n";

sleep($seconds); # number is integer in seconds

 

microseconds:

echo "Sleeping...\n";

usleep($microseconds); # number is integer in microseconds

 

nanoseconds:

echo "Sleeping...\n";

time_nanosleep($seconds, $nanoseconds); # first arg in seconds plus second arg in nanoseconds

 

=={{header|PicoLisp}}==

(wait 2000) # Wait for 2 seconds

As [http://software-lab.de/doc/refW.html#wait wait] will continue executing

background events, another possibility (for a complete stop) is calling

some external program like

(call 'sleep 2) # Wait for 2 seconds

 

=={{header|PL/I}}==

put ('sleeping');

delay (2000); /* wait for 2 seconds (=2000 milliseconds). */

put ('awake');

 

=={{header|PowerShell}}==

Write-Host Sleeping ...

Start-Sleep $d

The <code>-Milliseconds</code> parameter to <code>Start-Sleep</code> can be used to allow for sub-second precision in sleeping.

 

 

=={{header|PureBasic}}==

Sleeping is performed with Delay() and a value in milliseconds. The time is accurate to approximately +/- 15 milliseconds.

 

Print("Enter a time(milliseconds) to sleep: ")

Input()

CloseConsole()

 

=={{header|Python}}==

 

 

seconds = float(raw_input())

print "Sleeping..."

time.sleep(seconds) # number is in seconds ... but accepts fractions

 

=={{header|R}}==

The call to flush.console is only needed if buffering is turned on. See [http://cran.r-project.org/bin/windows/base/rw-FAQ.html#The-output-to-the-console-seems-to-be-delayed FAQ for R on windows]. The time is given in seconds (fractions allowed, resolution is system dependent).

sleep <- function(time=1)

{

 

sleep()

 

=={{header|REBOL}}==

Title: "Sleep Main Thread"

URL: http://rosettacode.org/wiki/Sleep_the_Main_Thread

]

print "Sleeping..."

wait naptime

 

=={{header|Retro}}==

Retro has no fine grained timer; so we have to make due with seconds.

 

[ time [ time over - 1 > ] until drop ] times ;

: test

"\nTime to sleep (in seconds): " puts getToken toNumber

"\nSleeping..." sleep

 

=={{header|REXX}}==

 

Sleeping 4.7 seconds.

Awake!

</pre>

 

=={{header|Ruby}}==

puts "Sleeping..."

sleep(seconds) # number is in seconds ... but accepts fractions

# Minimum resolution is system dependent.

 

=={{header|Standard ML}}==

let val seconds = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn))) in

TextIO.print "Sleeping...\n";

I dunno why; it doesn't say anything about this in the documentation *)

TextIO.print "Awake!\n"

 

=={{header|Suneido}}==

{

Print("Sleeping...")

Sleep(time) // time is in milliseconds

Print("Awake!")

 

=={{header|Tcl}}==

Blocking example (the process is blocked preventing any background activity).

flush stdout

set millis [gets stdin]

puts Sleeping...

after $millis

 

A non-blocking example where background activity will occur.

flush stdout

set millis [gets stdin]

after $millis set ::wakeupflag 1

vwait ::wakeupflag

 

=={{header|TI-89 BASIC}}==

 

45 sleep</pre>

 

=={{header|UNIX Shell}}==

echo "Sleeping..."

 

=={{header|Vedit macro language}}==

Message("Sleeping...\n")

Sleep(#1)

 

{{omit from|M4}}