Sleep: Difference between revisions

{{trans|Python}}

print(‘Sleeping...’)

sleep(seconds)

=={{header|360 Assembly}}==

REENTRANT means the program can be called from several callers simultaneously. The program obtains storage (memory) at each invocation.

Sleep (logically swapped out task) is established through STIMER macro (SVC 47)

START

PRINT DATA,GEN

* --------------------------------------------------------------------

END SLEEP

'''output''' invoked with PARM='6' (+ sign indicates "problem state" (non system key) execution

<pre style="overflow:scroll">

=={{header|8051 Assembly}}==

Input and output is dependent on hardware. The time units are machine cycles, which depends both on the oscillator frequency and the oscillator periods to machine cycle conversion factor. This code puts the processor into 'idle' mode, where code execution is stopped and resumed via an interrupt.

jmp main

ORG TIMER0

; Awake!

=={{header|8th}}==

f:stdin f:getline

"Sleeping..." . cr

eval sleep

"Awake!" . cr bye

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program sleep64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

<pre>

Enter the time to sleep in seconds : 5

</pre>

=={{header|Action!}}==

BYTE RTCLOK2=$14

BYTE PALNTSC=$D014

PrintF("Waited %U-%U=%U frames / %U ms%E%E",end,beg,diff,diffMs)

OD

{{out}}

The following result has been obtained from PAL version of Atari 8-bit computer.

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|Aime}}==

# Sleep X seconds

#usleep(atoi(argv(1)));

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any for Microsoft Windows - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.8/algol68g-2.8.win32.zip/download 2.8.win32]}}

Only works for Microsoft Windows because it uses Windows-specific ping syntax.

INT milliseconds = read int; # ping uses milliseconds #

print ("Sleeping...");

# ping -n gives number of tries, -w timeout, and >NUL deletes output so the user does not see it #

print (new line);

=={{header|AntLang}}==

echo["Sleeping..."]

sleep[milliseconds]

=={{header|Applesoft BASIC}}==

The cycles and times calculated should only be taken as a minimum delay.

20 POKE 771,168: POKE 772,252

30 INPUT "ENTER WAIT VALUE (1-256) : ";A

70 PRINT "WAIT FOR "C" CYCLES OR "

80 PRINT C * 14 / 14.318181" MICROSECONDS"

Output:<pre>ENTER WAIT VALUE (1-256) : 256

WAIT FOR 167309 CYCLES OR

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

.align 4

=={{header|Arturo}}==

print "Sleeping..."

pause time

{{out}}

=={{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|AWK}}==

# syntax: GAWK -f SLEEP.AWK [seconds]

BEGIN {

while (systime() < t + seconds) {}

}

<p>commands and output:</p>

<pre>

The time unit for the Pause command is based on clock cycles, not seconds. At 15 MHz, one second is approximately equal to a value of 4500. At 6 MHz, one second is approximately 1800.

input→A

0→T

Disp "SLEEPING...",i

Pause T

=={{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.

==={{header|BASIC256}}===

input ms

print "Sleeping..."

pause ms

print "Awake!"

==={{header|True BASIC}}===

INPUT ms

PRINT "Sleeping..."

PAUSE ms

PRINT "Awake!"

==={{header|Yabasic}}===

The '''sleep-command''' has many different names: You may write <code>pause</code>, <code>sleep</code> or <code>wait</code> interchangeably; whatever you write, yabasic will always do exactly the same.

print "Sleeping..."

print "Awake!"

==={{header|Sinclair ZX81 BASIC}}===

(Oh, and the ZX81 character set doesn't include lower-case letters or an exclamation mark: so the message <tt>Awake!</tt> has to be replaced by <tt>AWAKE.</tt>)

20 PRINT "(IN TELEVISION FRAMES)"

30 INPUT SLEEPTIME

40 PRINT "SLEEPING... ";

50 PAUSE SLEEPTIME

==={{header|BaCon}}===

'---The SLEEP command takes milliseconds by default but we will adjust it

PRINT "Enter a number for each second you want to wait\nthen press Enter "

SLEEP millisec * 1000

PRINT "Awake!"

==={{header|ZX Spectrum Basic}}===

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

20 LET s = 5

30 PRINT "Sleeping"

40 PAUSE s * 50

=={{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|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PRINT "Sleeping..."

WAIT sleep%

Whilst sleeping BBC BASIC for Windows periodically tests for the ESCape key being pressed.

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

#include <unistd.h>

printf("Awake!\n");

return 0;

=={{header|C sharp|C#}}==

using System.Threading;

Console.WriteLine("Awake!");

}

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

{{works with|C++11}}

#include <thread>

#include <chrono>

std::cout << "Awake!\n";

}

{{works with|POSIX}}

#include <iostream>

cout << "Awake!" << endl;

return 0;

=={{header|Caché ObjectScript}}==

SLEEP

; the HANG command can use fractional seconds; the Awake line will be slightly off due to processing time

write !,"Awake! Time is "_$ztime($piece($ztimestamp,",",2,2),1,2)

quit

{{out}}<pre>

=={{header|Clojure}}==

(println "Sleeping...")

(Thread/sleep ms)

(println "Awake!"))

; call it

=={{header|COBOL}}==

{{works with|ACUCOBOL-GT}}

{{works with|OpenCOBOL}}

PROGRAM-ID. Sleep-In-Seconds.

GOBACK

While the second expects the time to be in nanoseconds. Note: Windows systems can only sleep to the nearest millisecond.

{{works with|OpenCOBOL}}

PROGRAM-ID. Sleep-In-Nanoseconds.

GOBACK

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

(let ((seconds (read)))

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

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

=={{header|D}}==

void main() {

Thread.sleep(dur!"seconds"(secs));

writeln("Awake!");

{{out}}

<pre>Enter a time to sleep (in seconds): 5

=={{header|DCL}}==

$ write sys$output "Sleeping..."

$ wait 'amount_of_time

{{out}}

<pre>$ @sleep 1 ! sleeps for 1 hour

=={{header|DBL}}==

; Sleep for DBL version 4 by Dario B.

;

SLEEP 10 ;Sleep for 10 seconds

DISPLAY (1,"Awake!",10)

=={{header|Delphi}}==

{$APPTYPE CONSOLE}

Sleep(lTimeToSleep); // milliseconds

WriteLn('Awake!');

=={{header|Diego}}==

Diego is zero-threaded, meaning that the callee can handle the instruction how they wish (dependant on decision behaviour), however, the thread behaviour can be stipulated in code.

ask_human()_first()_msg(Enter number of seconds to sleep: )_var(sleepSecs)_me();

set_decision(asynchronous)_me();

exec_instruct(sleepTime)_me();

=={{header|DIBOL-11}}==

START ;Demonstrate the SLEEP function

=={{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|EGL}}==

// Syntax: sysLib.wait(time BIN(9,2) in)

end

=={{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):

=={{header|Elena}}==

ELENA 4.x :

public program()

system'threading'threadControl.sleep(sleep);

console.printLine("Awake!")

=={{header|Elixir}}==

IO.puts "Sleeping..."

:timer.sleep(1000 * seconds) # in milliseconds

sec = if System.argv==[], do: 1, else: hd(System.argv) |> String.to_integer

=={{header|Emacs Lisp}}==

(message "Sleeping ...")

(sleep-for seconds)

The time can be a decimal like 1.5 though the actual resolution of <code>sleep-for</code> depends on the operating system. The similar <code>sit-for</code> stops sleeping if there's pending keyboard input.

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|ERRE}}==

..............

INPUT("Enter the time to sleep in seconds: ";sleep)

PRINT("Awake!")

..............

=={{header|F_Sharp|F#}}==

{{trans|C#}}

open System.Threading

Thread.Sleep(sleep); //milliseconds

Console.WriteLine("Awake!")

=={{header|Factor}}==

: read-sleep ( -- )

"Sleeping..." print

sleep

=={{header|Fantom}}==

Fantom has a 'Duration' class, which uses time definitions with units: e.g., 5sec, 100ns, 5hr. These are used for input in the following program.

using concurrent

}

}

Output:

=={{header|FBSL}}==

DIM %msec

PRINT "Milliseconds to sleep: ";

PRINT "Awake!"

PAUSE

Output

<pre>Milliseconds to sleep: 1000

=={{header|Forth}}==

." Sleeping..."

ms

====Explanation note on MS====

=={{header|Fortran}}==

implicit none

end if

=={{header|FreeBASIC}}==

Dim ms As UInteger

Sleep ms, 1 '' the "1" means Sleep can't be interrupted with a keystroke

Print "Awake!"

Sample input/output

=={{header|Frink}}==

In Frink, all values have units of measure, and sleep functions take units of time, which can be seconds, nanoseconds, minutes, hours, etc. The user may enter values like "3 hours" or "1 ms". The units of measure are captured as first-class values in the language, and not hidden in comments nor implied in APIs.

do

t = eval[input["Enter amount of time to sleep: ", "1 second"]]

sleep[t]

println["Awake!"]

=={{header|Go}}==

Technically, this varies from the task by sleeping the main ''goroutine'' rather than the main ''thread''. The Go runtime multiplexes goroutines to operating system threads and the language does not provide direct access to threads.

import "time"

time.Sleep(time.Duration(sec * float64(time.Second)))

fmt.Println("\nAwake!")

=={{header|Groovy}}==

Solution:

println("Sleeping...")

sleep(it)

println("Awake!")

Test:

print '''

Hmmm. That was... less than satisfying.

}

}

Output:

=={{header|Haskell}}==

main = do seconds <- readLn

putStrLn "Sleeping..."

threadDelay $ round $ seconds * 1000000

=={{header|HicEst}}==

WRITE(StatusBar) "Sleeping ... "

SYSTEM(WAIT = milliseconds)

=={{header|Icon}} and {{header|Unicon}}==

repeat {

delay(1000 * s)

write("Awake!")

=={{header|IDL}}==

read,i,prompt='Input sleep time in seconds: '

print,'Sleeping...'

wait,i ; in seconds, but accepts floats(/fractional) as input

print,'Awake!'

=={{header|J}}==

'''Solution''':

sleeping=: monad define

sleep y

smoutput 'Awake!'

'''Example''':

Sleeping...

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.InputMismatchException;

import java.util.Scanner;

}

}

=={{header|JavaScript}}==

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.

setTimeout(function () {

document.write('Sleeping... ');

=={{header|Jsish}}==

Sleep, in Jsish

*/

puts('Sleeping...');

sleep(ms);

=={{header|Julia}}==

print("Please enter sleep duration in seconds: ")

input = int(readline(STDIN))

sleep(input)

println("Awake!")

=={{header|Kotlin}}==

fun main(args: Array<String>) {

Thread.sleep(ms)

println("Awake!")

Sample input/output:

{{out}}

Lasso has a built in sleep command that accepts milliseconds as an input.

sleep(5000) // Sleep 5 seconds

=={{header|Lhogho}}==

The Logo version works without modification. Another way to Sleep, in the Windows version of Lhogho, is to use the Win32 function, viz

make "Long "U4

make "kernel32_handle libload "kernel32.dll

Sleep :n ; units: 1/1000th of a second

print [Awake.]

=={{header|Liberty BASIC}}==

Print "Sleeping..."

CallDLL #kernel32, "Sleep", sleeptime As long, ret As void

Print "Awake!"

=={{header|Lingo}}==

{{libheader|CommandLine Xtra}}

put "Sleeping..."

sleep(ms)

put "Awake!"

=={{header|Logo}}==

to sleep :n

print [Sleeping...]

print [Awake.]

end

=={{header|Logtalk}}==

Works when using SWI-Prolog, XSB, or YAP as the backend compilers:

:- object(sleep).

:- end_object.

Sample output:

| ?- sleep::how_long(5).

Sleeping ...

... awake!

yes

=={{header|Lua}}==

{{libheader|LuaSocket}}

The input does not need to be a whole number, eg. "0.5" would cause the program to wait for half a second.

io.write("Input a number of seconds to sleep: ")

local input = io.read("*number")

print("Sleeping")

socket.sleep(input)

A similar effect could be achieved using a "busy" loop but the function in lua-socket is gentler on your CPU.

=={{header|M2000 Interpreter}}==

Statement Wait pause the current thread but other threads from module (not in this example) may run.

Module CheckIt {

Input "Input a number of milliseconds to sleep:", N

}

CheckIt

=={{header|Maple}}==

print("Sleeping...");

Threads:-Sleep(secs);

print("Awake!");

=={{header|Mathematica}}/{{header|Wolfram Language}}==

This function, as you can probably guess, takes its argument in seconds.

While this function does tie up execution (but not with a busy wait), the Mathematica front end remains fully functional and can be used to stop the sleeping with Evaluation -> Abort Evaluation.

=={{header|MATLAB}} / {{header|Octave}}==

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

disp('Awake!');

=={{header|min}}==

{{works with|min|0.19.6}}

"Sleeping..." puts!

sleep

=={{header|Nanoquery}}==

println "Sleeping..."

sleep(time)

=={{header|Nemerle}}==

using System.Console;

using System.Threading.Thread; // this is where the Sleep() method comes from

WriteLine("Awake!");

}

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

say

return

=={{header|NewLISP}}==

(sleep 2000) ; Wait for 2 seconds

=={{header|Nim}}==

echo "Enter how long I should sleep (in milliseconds):"

echo "Sleeping..."

sleep timed

=={{header|NS-HUBASIC}}==

The <code>PAUSE</code> statement pauses execution for a length of time expressed in terms of the frame rate of the television you are using as a monitor.

20 PAUSE 100

=={{header|Objeck}}==

bundle Default {

class Test {

}

}

=={{header|Objective-C}}==

{{works with|GNUstep}} and {{works with|Cocoa}}

int main()

}

return 0;

=={{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|Oforth}}==

=={{header|ooRexx}}==

Call sysSleep 10 -- wait 10 seconds

{{out}}

<pre>14:23:40

=={{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}}==

===gettime===

The units are milliseconds.

print("Sleeping...");

while((ms-=gettime()) > 0,);

};

===alarm===

{{works with|PARI/GP|2.4.3 and above on Linux}}

The units are seconds.

print("Sleeping...");

alarm(s);

};

=={{header|Pascal}}==

=={{header|Peloton}}==

Literate mode

<@ SAYLIT>Sleeping</@>

<@ ACTPAUVAR>secs</@>

French variable-length opcodes

<# MontrezLittéralement>Sleeping</#>

<# AgissezFaireUnePauseVariable>secs</#>

(Simplified) Chinese fixed-length opcodes

<@ 显示_字串_>Sleeping</@>

<@ 运行_暂停动变量_>secs</@>

=={{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;

It's also possible to sleep for fractional seconds by abusing the select function:

select undef, undef, undef, 0.5;

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (prompt_number, sleep)</span>

<span style="color: #004080;">atom</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prompt_number</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"wait for duration (in seconds, 0..20):"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">20</span><span style="color: #0000FF;">})</span>

<span style="color: #7060A8;">sleep</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Awake!\n"</span><span style="color: #0000FF;">)</span>

Note that sleep() is entirely inappropriate for GUI applications, which should instead set a routine to resume processing

(that would be timer_cb below), activate a timer (set RUN to true), and relinquish control to the event loop. Another

excellent way to perform extended processing without making an application unresponsive is via an IDLE_ACTION, provided

that also regularly relinquishes control to the event loop, and can pick up where it left off when next invoked.

<span style="color: #000080;font-style:italic;">-- demo\rosetta\sleep.exw</span>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

=={{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|Pike}}==

int seconds = (int)Stdio.stdin->gets();

write("Sleeping...\n");

write("Awake!\n");

return 0;

=={{header|Pixilang}}==

sleep(1000)

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

put ('sleeping');

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

put ('awake');

=={{header|Plain English}}==

Start up.

Demonstrate waiting.

Write "Sleeping..." to the console.

Wait for the milliseconds.

=={{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.