Sleep

From Rosetta Code
Revision as of 13:27, 9 December 2014 by Walterpachl (talk | contribs) (add ooRexx)
Task
Sleep
You are encouraged to solve this task according to the task description, using any language you may know.

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.
  • Print "Sleeping..."
  • Sleep the main thread for the given amount of time.
  • Print "Awake!"
  • End.
Cf.

360 Assembly

REENTRANT means the program can be called from several callers simultanously. The program obtains storage (memory) at each invocation. Sleep (logically swapped out task) is established through STIMER macro (SVC 47) <lang 360 Assembly>

        START 
        PRINT DATA,GEN 
        YREGS ,                      REGISTER EQUATES (e.g. 0 = R0) 

SLEEP CSECT SLEEP AMODE 31 addressing mode 31 bit SLEEP RMODE ANY loader determines 31 or 24

  • REENTRANT. Logically swap out a task for a number of seconds
  • specified in PARM. Minimum 0, maximum 60 seconds
  • MVS rexx (the original rexx) does not have a sleep function. This
  • program can be called from rexx, assuming this program is in
  • LINKLIST, as follows:
  • /* rexx */
  • wait_time = '6' /* number of seconds to sleep */
  • say 'Sleeping...'
  • address LINKMVS "SLEEP wait_time" /* invoke SLEEP */
  • say 'Awake!

PROLOG BAKR R14,0 satck caller's registers

        LR    R4,R1                 save parm pointer 
        LR    R12,R15               entry point addr to R12 
        USING SLEEP,R12             tell assembler about that 
        B     AROUND                avoid abend S0C1 
        DC    C'SLEEP '             CSECT NAME 
        DC    C'C=2014.05.10 '      CHANGE DATE 
        DC    C'A=&SYSDATE '        ASSEMBLY DATE 
        DC    C'T=&SYSTIME '        CHANGE TIME 
        DC    C'MarcvdM. '          PROGRAMMER NAME 

AROUND L R10,0(0,R4) load parm address in R10

        XR    R15,R15               clear R15 
        LH    R15,0(0,R10)          load parm length in R15 
        LR    R6,R15                save length in R6 
        LTR   R15,R15               parm length 0? 
        BZ    NOPARM                yes, exit before getmain 
        C     R6,F2                 parmlength > 2 ? 
        BH    NOPARM                yes, exit before getmain 
       STORAGE OBTAIN,LENGTH=WALEN,LOC=ANY  get some storage 
        LR    R9,R1                 address of storage in R9 
        USING WAREAX,R9             base for data section (DSECT) 
        MVC   EYECAT,=C'**MARC**'   make storage easy to find in dump 
        MVC   SECONDS,C00           set field to F0F0 
        C     R6,F1                 parmlength = 1? 
        BNE   COPYSECS              no, copy both bytes 
        MVC   SECONDS+1(1),2(R10)   yes, just copy one byte. 
        B     TRTEST 

COPYSECS MVC SECONDS,2(R10)

  • test supplied parameter for valid integer values

TRTEST TRT SECONDS(1),VALINT6 first parm byte no higher as 6?

        BNZ   NOPARM_REL            higher, release storage and return
        TRT   SECONDS+1(1),VALINT9  second byte valid? 
        BNZ   NOPARM_REL            no, release storage and return 
        CLC   SECONDS(1),=C'6'      first parm byte < 6? 
        BNE   DOWAIT                yes, do wait 
        CLC   SECONDS+1(1),=C'0'    first eq. 6, second > 0? 
        BNE   NOPARM_REL            yes, release storage and return 

DOWAIT DS 0H

        MVC   WAWTO(DWTOL),DWTO     copy WTO list form to obtained st.
        MVC   WAWTO+18(2),SECONDS   copy in nr. of seconds 
       WTO    MF=(E,WAWTO)          issue WTO, execute form 
        MVC   HOURS,C00             zero out hours 
        MVC   MINUTS,C00             and minutes 
        MVC   REST,C00                and milliseconds 
       STIMER WAIT,DINTVL=TIMEVAL   SVC 47: logical swap out (sleep) 
        B     EXIT                  done 

NOPARM_REL DS 0H

       STORAGE RELEASE,ADDR=(R9),LENGTH=WALEN  free obtained storage 
        LA    R15,4                 set return code 4 
        B     RETURN                return to caller 

EXIT DS 0H

       STORAGE RELEASE,ADDR=(R9),LENGTH=WALEN  free obtained storage 
       WTO    ' Awake!',ROUTCDE=11   fixed wake-up string 

NOPARM EQU * RETURN PR , return to caller

  • --------------------------------------------------------------------
  • CONSTANTS
  • --------------------------------------------------------------------

DWTO WTO ' Sleeping... (XX seconds)',ROUTCDE=11,MF=L DWTOL EQU *-DWTO length of WTO list form F1 DC F'1' F2 DC F'2' C00 DC C'00' VALINT6 DC 256XL1'01'

         ORG   *-16 

VALOK6 DC 7XL1'00' F0-F6: OFFSETS 240-246 VALINT9 DC 256XL1'01'

         ORG   *-16 

VALOK9 DC 10XL1'00' F0-F9: OFFSETS 240-249

         DS    0D 
        LTORG ,                   FORCE DISPLACEMENT LITERALS 
  • --------------------------------------------------------------------
  • DSECT (data section)
  • --------------------------------------------------------------------

WAREAX DSECT , WAWTO DS CL(DWTOL) reentrant WTO area EYECAT DS CL8 TIMEVAL DS 0CL8 HOURS DS CL2 will be zeroed MINUTS DS CL2 will be zeroed SECONDS DS CL2 from parm REST DS CL2 will be zeroed WALEN EQU *-WAREAX length of DSECT

  • --------------------------------------------------------------------
        END   SLEEP 

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

+ Sleeping... (06 seconds)  
+ Awake!                    

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. <lang asm>ORG RESET jmp main ORG TIMER0 ; timer interrupt only used to wake the processor clr tr0 reti

main: setb ea ; enable interrupts setb et0 ; enable timer0 interrupt mov tl0, #0 ; start timer counter at zero mov th0, #0 ; these two values dictate the length of sleep

mov a, pcon ; copy power control register setb a.0 ; set idl bit setb tr0 ; start timer ; sleeping... mov pcon, a ; move a back into pcon (processor sleeps after this instruction finishes)

; when the timer overflows and the timer interrupt returns, execution will resume at this spot

; Awake! jmp $</lang>

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.

<lang ada>with Ada.Text_Io; use Ada.Text_Io; with Ada.Float_Text_Io; use Ada.Float_Text_Io;

procedure Sleep is

  In_Val : Float;

begin

  Get(In_Val);
  Put_Line("Sleeping...");
  delay Duration(In_Val);
  Put_Line("Awake!");

end Sleep;</lang>

Aime

<lang aime>o_text("Sleeping...\n");

  1. Sleep X seconds

sleep(atoi(argv(1)));

  1. Sleep X microseconds
  2. usleep(atoi(argv(1)));

o_text("Awake!\n");</lang>

AutoHotkey

<lang AutoHotkey>TrayTip, sleeping, sleeping sleep, 2000 ; 2 seconds TrayTip, awake, awake Msgbox, awake</lang>

AutoIt

<lang AutoIt>#AutoIt Version: 3.2.10.0 $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) MsgBox(0,"Awake","... Awaking")</lang>

AWK

<lang AWK>

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

BEGIN {

   print("Sleeping...")
   loop(ARGV[1])
   print("Awake!")
   exit(0)

} function loop(seconds, t) {

  1. awk lacks a sleep mechanism, so simulate one by looping
   t = systime()
   while (systime() < t + seconds) {}

} </lang>

commands and output:

GAWK "BEGIN{print(strftime())}"
GAWK -f SLEEP.AWK 3
GAWK "BEGIN{print(strftime())}"

Wed Jan 16 18:06:44 Eastern Standard Time 2013
Sleeping...
Awake!
Wed Jan 16 18:06:47 Eastern Standard Time 2013

BASIC

Works with: QuickBasic version 4.5

<lang qbasic>INPUT sec 'the SLEEP command takes seconds PRINT "Sleeping..." SLEEP sec PRINT "Awake!"</lang> "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.

ZX Spectrum Basic

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

<lang zxbasic>10 REM s is the number of seconds 20 LET s = 5 30 PRINT "Sleeping" 40 PAUSE s * 50 50 PRINT "Awake"</lang>

Batch File

The usual way to do this is to use the ping utility which waits a second between multiple tries. To wait n seconds one tells ping to make n + 1 tries and redirects the output:

Works with: Windows NT version 4

<lang dos>@echo off set /p Seconds=Enter the number of seconds to sleep: set /a Seconds+=1 echo Sleeping ... ping -n %Seconds% localhost >nul 2>&1 echo Awake!</lang> A similar trick can be used to wait a certain number of milliseconds. The ping utility includes a /w 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

<lang dos>@echo off set /p MilliSeconds=Enter the number of milliseconds to sleep: echo Sleeping ... ping -n 1 -w %MilliSeconds% 1.2.3.4 >nul 2>&1 echo Awake!</lang>

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

Works with: Windows Vista

<lang dos>@echo off set /p Seconds=Enter the number of seconds to sleep: echo Sleeping ... timeout /t %Seconds% /nobreak >nul echo Awake!</lang>

BBC BASIC

<lang bbcbasic> INPUT "Enter the time to sleep in centiseconds: " sleep%

     PRINT "Sleeping..."
     WAIT sleep%
     PRINT "Awake!"</lang>

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

C

Works with: POSIX

The function sleep needs seconds, which are read from the standard input.

<lang c>#include <stdio.h>

  1. include <unistd.h>

int main() {

 unsigned int seconds;
 scanf("%u", &seconds);
 printf("Sleeping...\n");
 sleep(seconds);
 printf("Awake!\n");
 return 0;

}</lang>

C++

Works with: C++11

<lang cpp>#include <iostream>

  1. include <thread>
  2. include <chrono>

int main() {

   unsigned long microseconds;
   std::cin >> microseconds;
   std::cout << "Sleeping..." << std::endl;
   std::this_thread::sleep_for(std::chrono::microseconds(microseconds));
   std::cout << "Awake!\n";

} </lang>

Works with: POSIX

<lang cpp>#include <unistd.h>

  1. include <iostream>

using namespace std;

int main(int argc, char* argv[]) {

   useconds_t microseconds;
   cin >> microseconds;
   cout << "Sleeping..." << endl;
   usleep(microseconds);
   cout << "Awake!" << endl;
   return 0;

}</lang>

C#

<lang csharp>using System; using System.Threading;

class Program {

   static void Main(string[] args)
   {
       int sleep = Convert.ToInt32(Console.ReadLine());
       Console.WriteLine("Sleeping...");
       Thread.Sleep(sleep); //milliseconds
       Console.WriteLine("Awake!");
   }

}</lang>


Clojure

<lang clojure>(defn sleep [ms] ; time in milliseconds

 (println "Sleeping...")
 (Thread/sleep ms)
 (println "Awake!"))
call it

(sleep 1000)</lang>

COBOL

There are two methods for putting the program to sleep, both requiring unofficial extensions. The first expects the amount of time to be in seconds.

Works with: ACUCOBOL-GT
Works with: OpenCOBOL

<lang cobol> IDENTIFICATION DIVISION.

      PROGRAM-ID. Sleep-In-Seconds.
      DATA DIVISION.
      WORKING-STORAGE SECTION.
      01  Seconds-To-Sleep       USAGE COMP-2.
      PROCEDURE DIVISION.
          ACCEPT Seconds-To-Sleep
          DISPLAY "Sleeping..."
          CALL "C$SLEEP" USING BY CONTENT Seconds-To-Sleep
          DISPLAY "Awake!"
          GOBACK
          .</lang>

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

Works with: OpenCOBOL

<lang cobol> IDENTIFICATION DIVISION.

      PROGRAM-ID. Sleep-In-Nanoseconds.
      DATA DIVISION.
      WORKING-STORAGE SECTION.
      01  Seconds-To-Sleep       USAGE COMP-2.
      01  Nanoseconds-To-Sleep   USAGE COMP-2.
      01  Nanoseconds-Per-Second CONSTANT 1000000000.
      PROCEDURE DIVISION.
          ACCEPT Seconds-To-Sleep
          MULTIPLY Seconds-To-Sleep BY Nanoseconds-Per-Second
              GIVING Nanoseconds-To-Sleep
          DISPLAY "Sleeping..."
          CALL "CBL_OC_NANOSLEEP"
              USING BY CONTENT Nanoseconds-To-Sleep
          DISPLAY "Awake!"
          GOBACK
          .</lang>

Common Lisp

<lang lisp>(defun test-sleep ()

 (let ((seconds (read)))
   (format t "Sleeping...~%")
   (sleep seconds)
   (format t "Awake!~%")))

(test-sleep)</lang>

D

<lang d>import std.stdio, core.thread;

void main() {

   write("Enter a time to sleep (in seconds): ");
   long secs;
   readf(" %d", &secs);
   writeln("Sleeping...");
   Thread.sleep(dur!"seconds"(secs));
   writeln("Awake!");

}</lang>

Output:
Enter a time to sleep (in seconds): 5
Sleeping...
Awake!

Delphi

<lang Delphi>program SleepOneSecond;

{$APPTYPE CONSOLE}

uses SysUtils;

var

 lTimeToSleep: Integer;

begin

 if ParamCount = 0 then
   lTimeToSleep := 1000
 else
   lTimeToSleep := StrToInt(ParamStr(1));
 WriteLn('Sleeping...');
 Sleep(lTimeToSleep); // milliseconds
 WriteLn('Awake!');

end.</lang>

E

You can't do that.

No, really. E's approach to timing, concurrency, and IO is non-blocking; if you want to wait for something, you say what you want to do when it happens — i.e. callbacks. There are no threads of control which can be stopped — except automatically when they just have nothing to do.

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.

<lang e>def sleep(milliseconds :int, nextThing) {

   stdout.println("Sleeping...")
   timer.whenPast(timer.now() + milliseconds, fn {
       stdout.println("Awake!")
       nextThing()
   })

}</lang>

EGL

<lang EGL>program Sleep type BasicProgram{}

   // Syntax: 	sysLib.wait(time BIN(9,2) in)
   function main()
   	SysLib.writeStdout("Sleeping!");
       sysLib.wait(15); // waits for 15 seconds
       SysLib.writeStdout("Awake!");	
   end

end</lang>

Eiffel

The feature sleep is defined in the library class EXECUTION_ENVIRONMENT. So the demonstration class APPLICATION inherits from EXECUTION_ENVIRONMENT in order to make sleep available.

sleep takes an argument which declares the number of nanoseconds to suspend the thread's execution.

<lang eiffel >class

   APPLICATION

inherit

   EXECUTION_ENVIRONMENT

create

   make

feature -- Initialization

   make
           -- Sleep for a given number of nanoseconds.
       do
           print ("Enter a number of nanoseconds: ")
           io.read_integer_64
           print ("Sleeping...%N")
           sleep (io.last_integer_64)
           print ("Awake!%N")
       end

end</lang>

Output (sleeping 10 seconds):

Enter a number of nanoseconds: 10000000000
Sleeping...
Awake!

Emacs Lisp

<lang lisp>(let ((seconds (read-number "Time in seconds: ")))
 (message "Sleeping ...")
 (sleep-for seconds)
 (message "Awake!"))</lang>

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

read-number is new in Emacs 22 and XEmacs 21. In earlier versions similar can be had with

<lang lisp>(string-to-number (read-string "Time in seconds: "))</lang>

This returns 0 on a non-number whereas read-number re-prompts (except in Emacs 24.3 where a bug caused read-number to return 0 :-( ).

Erlang

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

   io:format("Sleeping...~n"),
   timer:sleep(1000), %% in milliseconds
   io:format("Awake!~n").</lang>

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

   io:format("Sleeping...~n"),
   receive
   after 1000 -> ok %% in milliseconds
   end,
   io:format("Awake!~n").</lang>

which is the way it is implemented in the timer module.

F#

Translation of: C#

<lang fsharp>open System open System.Threading

[<EntryPoint>] let main args =

   let sleep = Convert.ToInt32(Console.ReadLine())
   Console.WriteLine("Sleeping...")
   Thread.Sleep(sleep); //milliseconds
   Console.WriteLine("Awake!")
   0</lang>

Factor

<lang factor>USING: calendar io math.parser threads ;

read-sleep ( -- )
   readln string>number seconds
   "Sleeping..." print
   sleep
   "Awake!" print ;</lang>

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.

<lang fantom> using concurrent

class Main {

 public static Void main ()
 {
   echo ("Enter a time to sleep: ")
   input := Env.cur.in.readLine
   try
   {
     time := Duration.fromStr (input)
     echo ("sleeping ...")
     Actor.sleep (time)
     echo ("awake!")
   }
   catch
   {
     echo ("Invalid time entered")
   }
 }

} </lang>

Output:

Enter a time to sleep: 
5sec
sleeping ...
awake!

FBSL

<lang qbasic>#APPTYPE CONSOLE DIM %msec PRINT "Milliseconds to sleep: "; %msec = FILEGETS(stdin, 10) PRINT "Sleeping..." SLEEP(%msec) PRINT "Awake!" PAUSE </lang> Output

Milliseconds to sleep: 1000
Sleeping...
Awake!

Press any key to continue...

Forth

<lang forth>: sleep ( ms -- )

 ." Sleeping..."
 ms
 ." awake." cr ;</lang>

Fortran

<lang fortran>program test_sleep

 implicit none
 integer :: iostat
 integer :: seconds
 character (32) :: argument
 if (iargc () == 1) then
   call getarg (1, argument)
   read (argument, *, iostat = iostat) seconds
   if (iostat == 0) then
     write (*, '(a)') 'Sleeping...'
     call sleep (seconds)
     write (*, '(a)') 'Awake!'
   end if
 end if

end program test_sleep</lang>

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. <lang frink> do

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

while ! (t conforms time)

println["Sleeping..."] sleep[t] println["Awake!"] </lang>

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. <lang go>package main

import "time" import "fmt"

func main() {

   fmt.Print("Enter number of seconds to sleep: ")
   var sec float64
   fmt.Scanf("%f", &sec)
   fmt.Print("Sleeping…")
   time.Sleep(time.Duration(sec * float64(time.Second)))
   fmt.Println("\nAwake!")

}</lang>

Groovy

Solution: <lang groovy>def sleepTest = {

   println("Sleeping...")
   sleep(it)
   println("Awake!")

}</lang>

Test: <lang groovy>sleepTest(1000) print Hmmm. That was... less than satisfying. How about this instead? Thread.start {

   (0..5).each {
       println it
       sleep(1000)
   }

} sleepTest(5000)</lang>

Output:

Sleeping...
Awake!

Hmmm. That was... less than satisfying
How about this instead?
Sleeping...
0
1
2
3
4
Awake!
5

Haskell

<lang haskell>import Control.Concurrent

main = do seconds <- readLn

         putStrLn "Sleeping..."
         threadDelay $ round $ seconds * 1000000
         putStrLn "Awake!"</lang>

HicEst

<lang hicest>DLG(NameEdit = milliseconds, Button = "Go to sleep") WRITE(StatusBar) "Sleeping ... " SYSTEM(WAIT = milliseconds) WRITE(Messagebox) "Awake!"</lang>

IDL

<lang IDL> read,i,prompt='Input sleep time in seconds: ' print,'Sleeping...' wait,i ; in seconds, but accepts floats(/fractional) as input print,'Awake!' </lang>

Icon and Unicon

<lang Icon>procedure main()

repeat {

  writes("Enter number of seconds to sleep :")
  s := reads()
  if s = ( 0 < integer(s)) then break
  }

write("\nSleeping for ",s," seconds.") delay(1000 * s) write("Awake!") end</lang>

J

Solution: <lang j>sleep =: 6!:3

sleeping=: monad define

 smoutput 'Sleeping...'
 sleep y
 smoutput 'Awake!'

)</lang>

Example: <lang j> sleeping 0.500 NB. Sleep 500 milliseconds Sleeping... Awake!</lang>

Java

Works with: Java version 1.5+

<lang java5> import java.util.InputMismatchException; import java.util.Scanner;

public class Sleep {

   public static void main(final String[] args) throws InterruptedException {
       try {
           int ms = new Scanner(System.in).nextInt(); //Java's sleep method accepts milliseconds
           System.out.println("Sleeping...");
           Thread.sleep(ms);
           System.out.println("Awake!");
       } catch (InputMismatchException inputMismatchException) {
           System.err.println("Exception: " + inputMismatchException);
       }
   }

}</lang>

JavaScript (in a web browser)

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.

<lang html><script>

 setTimeout(function () {
   document.write('Awake!')
 }, prompt("Number of milliseconds to sleep"));
 document.write('Sleeping... ');

</script></lang>

Julia

<lang Julia> print("Please enter sleep duration in seconds: ") input = int(readline(STDIN)) println("Sleeping...") sleep(input) println("Awake!") </lang>

Lasso

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

<lang Lasso>stdoutnl('Sleeping...') sleep(5000) // Sleep 5 seconds stdoutnl('Awake!')</lang>

LabVIEW

Uses milliseconds. LabVIEW has no "main thread" so it must be forced with a sequence structure.
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Lhogho

The Logo version works without modification. Another way to Sleep, in the Windows version of Lhogho, is to use the Win32 function, viz <lang logo>make "Void "V0 make "Long "U4 make "kernel32_handle libload "kernel32.dll to Sleep :dwMilliseconds end external "Sleep [ Void Sleep Long] :kernel32_handle

to millisleep :n print [Sleeping...] Sleep :n  ; units: 1/1000th of a second print [Awake.] end</lang>

Liberty BASIC

<lang lb>Input "Please input the number of milliseconds you would like to sleep. "; sleeptime Print "Sleeping..." CallDLL #kernel32, "Sleep", sleeptime As long, ret As void Print "Awake!"

</lang>

<lang logo> to sleep :n print [Sleeping...] wait :n  ; units: 1/60th of a second print [Awake.] end </lang>

Logtalk

Works when using SWI-Prolog, XSB, or YAP as the backend compilers: <lang logtalk>

- object(sleep).
   :- public(how_long/1).
   how_long(Seconds) :-
       write('Sleeping ...'), nl,
       thread_sleep(Seconds),
       write('... awake!'), nl.
- end_object.

</lang> Sample output: <lang text> | ?- sleep::how_long(5). Sleeping ... ... awake! yes </lang>

Maple

<lang Maple>sleep := proc(secs)

          print("Sleeping...");
          Threads:-Sleep(secs);
          print("Awake!");
        end proc:</lang>

Mathematica

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.

<lang Mathematica> Sleep[seconds_] := (Print["Sleeping..."]; Pause[seconds]; Print["Awake!"];) </lang>

MATLAB / Octave

<lang MATLAB>function sleep()

   time = input('How many seconds would you like me to sleep for? ');
   assert(time > .01);
   disp('Sleeping...');
   pause(time);
   disp('Awake!');
   

end</lang>

Nemerle

<lang Nemerle>using System; using System.Console; using System.Threading.Thread; // this is where the Sleep() method comes from

module Zzzz {

   Main() : void
   {
       def nap_time = Int32.Parse(ReadLine());
       WriteLine("Sleeping...");
       Sleep(nap_time); // parameter is time in milliseconds
       WriteLine("Awake!");
   }

}</lang>

NetRexx

<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary

runSample(arg) return

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method sleep(secs) public static binary

 ms = (secs * 1000).format(null, 0) -- milliseconds, rounded to nearest integer
 say 'Sleeping...'
 do
   Thread.sleep(ms)
 catch ix = InterruptedException
   say 'Sleep interrupted!'
   ix.printStackTrace()
 end
 say 'Awake!'
 return

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method runSample(arg) public static

 secs = -1
 loop until \secs.datatype('N')
   if secs > 0 then do
     say 'Napping for' secs's'
     say
     sleep(secs)
   end
   say
   say 'How many seconds do you want me to sleep? (enter something non-numeric to terminate)\-'
   parse ask secs .
   say
   end
 say
 say 'Goodbye...'
 say
 return

</lang>

NewLISP

<lang NewLISP>(println "Sleeping..." ) (sleep 2000) ; Wait for 2 seconds (println "Awake!")</lang>

Nimrod

<lang Nimrod>import os, strutils

echo("Enter how long I should sleep (in milliseconds):") var timed = parseInt(readLine(stdin).string) echo("Sleeping...") sleep(timed) echo("Awake!")</lang>

Objective-C

Of course the same code of Sleep#C works for Objective-C. The following code uses a OpenStep derived framework (Cocoa, GNUstep...).

Works with: GNUstep
and
Works with: Cocoa

<lang objc>#import <Foundation/Foundation.h>

int main() {

 @autoreleasepool {
   NSTimeInterval sleeptime;
   printf("wait time in seconds: ");
   scanf("%f", &sleeptime);
   NSLog(@"sleeping...");
   [NSThread sleepForTimeInterval: sleeptime];
   NSLog(@"awakening...");
 }
 return 0;

}</lang>

Objeck

<lang objeck> bundle Default {

 class Test {
   function : Main(args : System.String[]) ~ Nil {
     if(args->Size() = 1) {
       "Sleeping..."->PrintLine();
       Thread->Sleep(args[0]->ToInt());
       "Awake!"->PrintLine();
     };
   }
 }

} </lang>

OCaml

<lang ocaml>#load "unix.cma";; let seconds = read_int ();; print_endline "Sleeping...";; Unix.sleep seconds;; (* number is integer in seconds *) print_endline "Awake!";;</lang>

or <lang ocaml>#load "unix.cma";;

  1. directory "+threads";;
  2. load "threads.cma";;

let seconds = read_float ();; print_endline "Sleeping...";; Thread.delay seconds;; (* number is in seconds ... but accepts fractions *) print_endline "Awake!";;</lang>

ooRexx

<lang oorexx>Say time() Call sysSleep 10 -- wait 10 seconds Say time()</lang

Output:
14:23:40
14:23:50

Oz

<lang oz>declare

 class TextFile from Open.file Open.text end
 StdIn = {New TextFile init(name:stdin)}
 WaitTime = {String.toInt {StdIn getS($)}}

in

 {System.showInfo "Sleeping..."}
 {Delay WaitTime} %% in milliseconds
 {System.showInfo "Awake!"}</lang>

PARI/GP

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

gettime

The units are milliseconds. <lang parigp>sleep(ms)={

 print("Sleeping...");
 while((ms-=gettime()) > 0,);
 print("Awake!")

};

sleep(input())</lang>

alarm

Works with: PARI/GP version 2.4.3 and above on Linux

The units are seconds. <lang parigp>sleep(s)={

 print("Sleeping...");
 alarm(s);
 trap(alarmer,,while(1,));
 print("Awake!")

};

sleep(input())</lang>

Pascal

See Delphi

Perl

seconds: <lang perl>$seconds = <>; print "Sleeping...\n"; sleep $seconds; # number is in seconds print "Awake!\n";</lang>

microseconds and nanoseconds using the Time::HiRes module: <lang perl>use Time::HiRes qw( usleep nanosleep );

$microseconds = <>; print "Sleeping...\n"; usleep $microseconds; print "Awake!\n";

$nanoseconds = <>; print "Sleeping...\n"; nanosleep $nanoseconds; print "Awake!\n";</lang>

It's also possible to sleep for fractional seconds by abusing the select function: <lang perl>say "Sleeping..."; select undef, undef, undef, 0.5; say "Awake!";</lang>

Perl 6

The sleep function argument is in units of seconds, but these may be fractional (to the limits of your system's clock).

<lang perl6>my $sec = prompt("Sleep for how many microfortnights? ") * 1.2096; say "Sleeping..."; sleep $sec; say "Awake!";</lang>

Note that 1.2096 is a rational number in Perl 6, not floating point, so precision can be maintained even when dealing with very small powers of ten.

PHP

seconds: <lang php>$seconds = 42; echo "Sleeping...\n"; sleep($seconds); # number is integer in seconds echo "Awake!\n";</lang>

microseconds: <lang php>$microseconds = 42000000; echo "Sleeping...\n"; usleep($microseconds); # number is integer in microseconds echo "Awake!\n";</lang>

nanoseconds: <lang php>$nanoseconds = 42000000000; echo "Sleeping...\n"; time_nanosleep($seconds, $nanoseconds); # first arg in seconds plus second arg in nanoseconds echo "Awake!\n";</lang>

PicoLisp

<lang PicoLisp>(prinl "Sleeping..." ) (wait 2000) # Wait for 2 seconds (prinl "Awake!")</lang> As wait will continue executing background events, another possibility (for a complete stop) is calling some external program like <lang PicoLisp>(prinl "Sleeping..." ) (call 'sleep 2) # Wait for 2 seconds (prinl "Awake!")</lang>

PL/I

<lang PL/I> put ('sleeping'); delay (2000); /* wait for 2 seconds (=2000 milliseconds). */ put ('awake'); </lang>

PowerShell

<lang powershell>$d = [int] (Read-Host Duration in seconds) Write-Host Sleeping ... Start-Sleep $d Write-Host Awake!</lang> The -Milliseconds parameter to Start-Sleep can be used to allow for sub-second precision in sleeping.

Prolog

Works with SWI-Prolog. <lang Prolog>rosetta_sleep(Time) :- writeln('Sleeping...'), sleep(Time), writeln('Awake!'). </lang>

Protium

Literate mode <lang html><@ SAYLIT>Number of seconds: </@><@ GETVAR>secs</@> <@ SAYLIT>Sleeping</@> <@ ACTPAUVAR>secs</@> <@ SAYLIT>Awake</@></lang>

French variable-length opcodes <lang html><# MontrezLittéralement>Number of seconds: </#><# PrenezUneValeurVariable>secs</#> <# MontrezLittéralement>Sleeping</#> <# AgissezFaireUnePauseVariable>secs</#> <# MontrezLittéralement>Awake</#></lang>

(Simplified) Chinese fixed-length opcodes <lang html><@ 显示_字串_>Number of seconds: </@><@ 获取_变量_>secs</@> <@ 显示_字串_>Sleeping</@> <@ 运行_暂停动变量_>secs</@> <@ 显示_字串_>Awake</@></lang>

PureBasic

Sleeping is performed with Delay() and a value in milliseconds. The time is accurate to approximately +/- 15 milliseconds. <lang PureBasic>If OpenConsole()

 Print("Enter a time(milliseconds) to sleep: ")
 x.i = Val(Input())
 PrintN("Sleeping...")
 Delay(x) ;in milliseconds
 PrintN("Awake!")
 Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
 Input()
 CloseConsole()

EndIf</lang>

Python

<lang python>import time

seconds = float(raw_input()) print "Sleeping..." time.sleep(seconds) # number is in seconds ... but accepts fractions print "Awake!"</lang>

R

The call to flush.console is only needed if buffering is turned on. See FAQ for R on windows. The time is given in seconds (fractions allowed, resolution is system dependent). <lang R> sleep <- function(time=1) {

  message("Sleeping...")
  flush.console()      
  Sys.sleep(time)
  message("Awake!")

}

sleep() </lang>

Racket

<lang racket>

  1. lang racket

(displayln "Enter a time (in seconds): ") (define time (read)) (when (number? time)

 (displayln "Sleeping...")
 (sleep time)
 (displayln "Awake!"))

</lang>

RapidQ

<lang vb> input "Enter the number of seconds to sleep: ";s sleep s print "I'm awake I think..." input "Press enter to quit";a$ </lang>

REBOL

<lang REBOL>REBOL [

   Title: "Sleep Main Thread"
   Date: 2009-12-15
   Author: oofoe
   URL: http://rosettacode.org/wiki/Sleep_the_Main_Thread

]

naptime: to-integer ask "Please enter sleep time in seconds: " print "Sleeping..." wait naptime print "Awake!"</lang>

Retro

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

<lang Retro>: sleep ( n- )

 [ time [ time over - 1 > ] until drop ] times ;
 : test
   "\nTime to sleep (in seconds): " puts getToken toNumber
   "\nSleeping..." sleep
   "\nAwake!\n" ;</lang>

REXX

using the DELAY BIF

This REXX version supplied   as is   works with   (without the accompanying external program shown below):

  • PC/REXX
  • Personal REXX

The above two REXXes supports fractional seconds. <lang rexx>/*REXX program sleeps X seconds (the # of seconds supplied by the arg.*/ parse arg secs . /*get a (possible) argument. */ secs=word(secs 0,1) /*if not present, assume 0 (zero)*/ say 'Sleeping' secs "seconds." /*tell 'em what's happening. */ call delay secs /*snooze. Hopefully, a short nap*/ say 'Awake!' /*and tell 'em we're running. */

                                      /*stick a fork in it, we're done.*/</lang>

output when using the following for input:   4.7

Sleeping 4.7 seconds.
Awake!

using the DELAY routine

The above REXX program (using DELAY) will work with most REXXes:

  • CMS REXX
  • PC/REXX   (see note)
  • Personal REXX   (see note)
  • REGINA REXX
  • ROO REXX
  • R4 REXX
  • TSO REXX
  • (Microsoft) DOS
  • (Microsoft) Windows
  • any system that supports the PING command

when used in conjunction with the following program (either external or imbedded).


Note:   when PC/REXX or Personal REXX are used, those REXXes already have a built-in function (BIF), so the   delay   subroutine (below) will never be executed, but the REXX   DELAY   BIF will be used instead.

This REXX program only uses whole seconds   (fractional seconds are ignored). <lang rexx>/*REXX program delays (or SLEEPS) a number of whole seconds. */ trace off /*suppress REXX error msgs.*/ parse arg ! /*obtain all the arguments.*/ if !all(arg()) then exit /*documentation requested? */ if !cms then address /*if CMS, use fast cmd path*/ signal on halt /*handle HALT gracefully.*/ signal on noValue /*handle REXX noValue error*/ signal on syntax /*handle REXX syntax errors*/

/*┌────────────────────────────────────────────────────────────────────┐ ┌─┘ The DELAY function is used to delay (wait) a specific amount of └─┐ │ (wall-clock) time specified in seconds. Any fraction part is ignored.│ │ │ │ If the REXX program invoking DELAY function is running under PC/REXX │ │ or Personal REXX, this REXX program should never be invoked as those │ └─┐ REXXes have their own built-in function (BIF) named "DELAY". ┌─┘

 └────────────────────────────────────────────────────────────────────┘*/

@cpsleep = 'CP SLEEP' /*point to (CP) SLEEP cmd*/ @ping = 'PING' /*point to the DOS PING cmd*/

parse var ! n _ /*parse argument from parms*/ if _\== | arg()>1 then call er 59 /*are there too many args? */ if n== then n=1 /*no arg? Then assume 1 sec*/ if \isNum(n) then call er 53,n 'delay-seconds' /*is n numeric? */ n=n%1 /*elide any fractional part*/ if n<=0 then return 0

                       /* ┌────────────────────┐ */
                       /* │ delay  n  seconds. │ */
                       /* └────────────────────┘ */
 select
 when !cms     then @cpsleep n%1 "SEC"              /*CMS? Use CP SLEEP*/
 when !tso     then call sleep n%1                  /*TSO?    Use SLEEP*/
 when !regina  then call sleep n%1                  /*Regina? Use SLEEP*/
 when !dos     then @ping '-n' n "127.0.0.1 > NUL"  /*DOS?    use PING */
 otherwise          nop
 end   /*select*/

return 0 /*return a zero value. */

/*═════════════════════════════general 1-line subroutines═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════*/

!all:  !!=!;!=space(!);upper !;call !fid;!nt=right(!var('OS'),2)=='NT';!cls=word('CLS VMFCLEAR CLRSCREEN',1+!cms+!tso*2);if arg(1)\==1 then return 0;if wordpos(!,'? ?SAMPLES ?AUTHOR ?FLOW')==0 then return 0;!call=']$H';call '$H' !fn !;!call=;return 1

!cal: if symbol('!CALL')\=="VAR" then !call=; return !call !env: !env='ENVIRONMENT'; if !sys=='MSDOS' | !brexx | !r4 | !roo then !env='SYSTEM'; if !os2 then !env='OS2'!env; !ebcdic=1=='f0'x; if !crx then !env='DOS'; return !fid: parse upper source !sys !fun !fid . 1 . . !fn !ft !fm .; call !sys; if !dos then do; _=lastpos('\',!fn); !fm=left(!fn,_); !fn=substr(!fn,_+1); parse var !fn !fn '.' !ft; end; return word(0 !fn !ft !fm, 1+('0'arg(1))) !rex: parse upper version !ver !vernum !verdate .; !brexx='BY'==!vernum; !kexx='KEXX'==!ver; !pcrexx='REXX/PERSONAL'==!ver | 'REXX/PC'==!ver; !r4='REXX-R4'==!ver; !regina='REXX-REGINA'==left(!ver,11); !roo='REXX-ROO'==!ver; call !env; return !sys: !cms=!sys=='CMS'; !os2=!sys=='OS2'; !tso=!sys=='TSO' | !sys=='MVS'; !vse=!sys=='VSE'; !dos=pos('DOS',!sys)\==0 | pos('WIN',!sys)\==0 | !sys=='CMD'; !crx=left(!sys,6)=='DOSCRX'; call !rex; return !var: call !fid; if !kexx then return space(dosenv(arg(1))); return space(value(arg(1),,!env)) er: parse arg _1,_2; call '$ERR' "14"p(_1) p(word(_1,2) !fid(1)) _2; if _1<0 then return _1; exit result p: return word(arg(1),1) halt: call er .1 isNum: return datatype(arg(1),'N') noValue: !sigl=sigl; call er 17,!fid(2) !fid(3) !sigl condition('D') sourceline(!sigl) syntax: !sigl=sigl; call er 13,!fid(2) !fid(3) !sigl !cal() condition('D') sourceline(!sigl)</lang>

Coding note:   the   !   subroutines (above) deal mostly with determining what version of REXX is being invoked and what operating system is being used;   and based on that information, appropriate flags (variables) are set.   This is an example of a robust boilerplate code checking for various versions of REXX and operating systems, and it also defines additional flags not used within this particular program.

Programming note:   The subroutine   $ERR   isn't included here; so here is the gist of the error messages:

  • er 59       too many arguments specified for the ─── DELAY ─── command.
  • er 53       argument ─── xxx ─── isn't numeric for the option ─── delay-seconds ─── for the ─── DELAY ─── command.

Ruby

<lang ruby>seconds = gets.to_f puts "Sleeping..." sleep(seconds) # number is in seconds ... but accepts fractions

  1. Minimum resolution is system dependent.

puts "Awake!"</lang>


Scala

Library: Scala
<lang scala>object Sleeper extends App {
 print("Enter sleep time in milli sec: ")
 val ms = scala.io.StdIn.readInt()
 println("Sleeping...")
 val sleepStarted = scala.compat.Platform.currentTime
 Thread.sleep(ms)
 println(s"Awaked after [${scala.compat.Platform.currentTime - sleepStarted} ms]1")

}</lang>

Scheme

Many Scheme implementations support srfi-18, a multithreading library which provides a 'thread-sleep!' function. The following works in Chicken Scheme:

<lang scheme> (use format) (use srfi-18)

(format #t "Enter a time (in seconds): ") (let ((time (read))) ; converts input to a number, if possible

 (if (number? time)
   (begin
     (format #t "Sleeping...~&")
     (thread-sleep! time)
     (format #t "Awake!~&"))
   (format #t "You must enter a number~&")))

</lang>

Scheme implementations also provide alternative approaches. For example, Chicken Scheme has a 'posix' library which includes a 'sleep' function.

Seed7

The duration.s7i library defines the function wait, which takes an argument of type duration. Functions to create durations with years, months, days, hours, minutes, seconds and micro seconds exist also.

<lang seed7>$ include "seed7_05.s7i";

 include "duration.s7i";

const proc: main is func

 local
   var integer: secondsToSleep is 0;
 begin
   write("Enter number of seconds to sleep: ");
   readln(secondsToSleep);
   writeln("Sleeping...");
   wait(secondsToSleep . SECONDS);
   writeln("Awake!");
 end func;</lang>

Smalltalk

Works with: Pharo

<lang smalltalk>t := (FillInTheBlankMorph request: 'Enter time in seconds') asNumber. Transcript show: 'Sleeping...'. (Delay forSeconds: t) wait. Transcript show: 'Awake!'. </lang>

Works with: Smalltalk/X

<lang smalltalk>t := (Dialog request: 'Enter time in seconds') asNumber. Transcript show: 'Sleeping...'. (Delay forSeconds: t) wait. Transcript show: 'Awake!'. </lang> (of course, you can "Smalltalk at:#FillInTheBlankMorph put:Dialog", to be source compatible with Pharo)

Standard ML

<lang ocaml>(TextIO.print "input a number of seconds please: "; let val seconds = valOf (Int.fromString (valOf (TextIO.inputLine TextIO.stdIn))) in

 TextIO.print "Sleeping...\n";
 OS.Process.sleep (Time.fromReal seconds);  (* it takes a Time.time data structure as arg,
                                              but in my implementation it seems to round down to the nearest second.
                                              I dunno why; it doesn't say anything about this in the documentation *)
 TextIO.print "Awake!\n"

end)</lang>

Suneido

<lang Suneido>function (time)

   {
   Print("Sleeping...")
   Sleep(time) // time is in milliseconds
   Print("Awake!")
   }</lang>

Tcl

Blocking example (the process is blocked preventing any background activity). <lang tcl>puts -nonewline "Enter a number of milliseconds to sleep: " flush stdout set millis [gets stdin] puts Sleeping... after $millis puts Awake!</lang>

A non-blocking example where background activity will occur. <lang tcl>puts -nonewline "Enter a number of milliseconds to sleep: " flush stdout set millis [gets stdin] set ::wakupflag 0 puts Sleeping... after $millis set ::wakeupflag 1 vwait ::wakeupflag puts Awake!</lang>

TI-89 BASIC

This example is in need of improvement:
Do something less wasteful than a busy wait, if possible.
Local dur_secs,st0,st,seconds
Define seconds() = Func
  Local hms
  getTime()→hms
  Return ((hms[1] * 60 + hms[2]) * 60) + hms[3]
EndFunc
ClockOn
  
Prompt dur_secs
Disp "Sleeping..."
seconds()→st
st→st0
While when(st<st0, st+86400, st) - st0 < dur_secs
  seconds()→st
EndWhile
Disp "Awake!"

Toka

This makes use of the sleep() function from libc which suspends execution for a specified number of seconds.

1 import sleep as sleep()
[ ." Sleeping...\n" sleep() drop ." Awake!\n" bye ] is sleep

45 sleep

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT secondsrange=2 PRINT "Sleeping ",secondsrange," seconds " WAIT #secondsrange PRINT "Awake after Naping ",secondsrange, " seconds" </lang>

UNIX Shell

<lang bash>printf "Enter a time in seconds to sleep: " read seconds echo "Sleeping..." sleep "$seconds" echo "Awake!"</lang>

This uses the sleep(1) command. POSIX sleep(1) only takes an integer, as in sleep 2, so you can only sleep for a whole number of seconds. Some systems extend sleep(1) to take a decimal fraction, as in sleep 2.5.

VBA

<lang VBA> Function Sleep(iSecsWait As Integer) Debug.Print Now(), "Sleeping..." Application.Wait Now + iSecsWait / 86400 'Time is stored as fractions of 24 hour day Debug.Print Now(), "Awake!" End Function </lang>


VBScript

<lang VBScript> iSeconds=InputBox("Enter a time in seconds to sleep: ","Sleep Example for RosettaCode.org") WScript.Echo "Sleeping..." WScript.Sleep iSeconds*1000 'Sleep is done in Milli-Seconds WScript.Echo "Awake!" </lang>

Vedit macro language

<lang vedit>#1 = Get_Num("Sleep time in 1/10 seconds: ") Message("Sleeping...\n") Sleep(#1) Message("Awake!\n")</lang>

zkl

<lang zkl>seconds:=ask("Seconds to sleep: ").toFloat(); println("Sleeping..."); Atomic.sleep(seconds); # float, usually millisecond resolution println("Awake!");</lang>