できない.dev

処理を一定時間待機させるには

処理を指定した時間だけ止めて待つ書き方を各言語で示す。
引数の単位が言語ごとに違う点と、Go の型エラー、Java の検査例外、JavaScript で待たずに先へ進む点もまとめる。

公開:

選んだ言語は、ほかのサンプルコードを開いたときも最初に表示する。

Python

import time
 
start = time.monotonic()
time.sleep(1.5)  # 引数は秒
print(f"{time.monotonic() - start:.1f}")  # 1.5

time.sleep に秒数を渡すと、その時間だけ処理が止まる。
1.5 のように小数も渡せる。
長さを測るには、システム時計の変更に左右されない time.monotonic を使う。

JavaScript

const { setTimeout: sleep } = require("node:timers/promises");
 
async function main() {
  const start = Date.now();
  await sleep(1500); // 引数はミリ秒
  console.log(((Date.now() - start) / 1000).toFixed(1)); // 1.5
}
 
main();

node:timers/promises の setTimeout は、指定したミリ秒のあとに解決する Promise を返す。
await で待てば、その行で処理が止まったように見える。
この間も Node.js は他の処理を進められる。

TypeScript

import { setTimeout as sleep } from "node:timers/promises";
 
async function main(): Promise<void> {
  const start = Date.now();
  await sleep(1500); // 引数はミリ秒
  console.log(((Date.now() - start) / 1000).toFixed(1)); // 1.5
}
 
main();

node:timers/promises の setTimeout は型定義つきで、Promise<void> を返す。
as sleep と別名にすると、グローバルの setTimeout と取り違えない。
await を使う関数は async にして Promise<void> を返す。

Go

package main
 
import (
	"fmt"
	"time"
)
 
func main() {
	start := time.Now()
	time.Sleep(1500 * time.Millisecond) // 引数は time.Duration
	fmt.Printf("%.1f\n", time.Since(start).Seconds()) // 1.5
}

time.Sleep の引数は time.Duration なので、time.Millisecond や time.Second を掛けて長さを表す。
time.Since に開始時刻を渡すと経過時間が得られる。

Rust

use std::thread::sleep;
use std::time::{Duration, Instant};
 
fn main() {
    let start = Instant::now();
    sleep(Duration::from_millis(1500)); // 引数は Duration
    println!("{:.1}", start.elapsed().as_secs_f64()); // 1.5
}

std::thread::sleep は現在のスレッドを止め、引数に Duration を取る。
Duration::from_millis や Duration::from_secs で長さを作る。
Instant::elapsed で経過時間を測れる。

Java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        long start = System.nanoTime();
        Thread.sleep(1500); // 引数はミリ秒
        System.out.printf("%.1f%n", (System.nanoTime() - start) / 1e9); // 1.5
    }
}

Thread.sleep にミリ秒を渡すと、現在のスレッドがその時間だけ止まる。
検査例外の InterruptedException を投げるため、throws で宣言するか try/catch で受ける必要がある。

C#

using System.Diagnostics;
 
var sw = Stopwatch.StartNew();
await Task.Delay(1500); // 引数はミリ秒
Console.WriteLine($"{sw.Elapsed.TotalSeconds:F1}"); // 1.5

Task.Delay にミリ秒を渡して await すると、スレッドを占有せずに待てる。
スレッドごと止めたいときは Thread.Sleep を使うが、非同期のコードでは Task.Delay を選ぶ。

引数の単位は言語ごとに違う

1.5 秒待つ書き方は、言語によって引数が次のように変わる。

  • Python の time.sleep は秒で、1.5 を渡す。
  • JavaScript・TypeScript の setTimeout、Java の Thread.sleep、C# の Task.Delay はミリ秒で、1500 を渡す。
  • Go の time.Sleep と Rust の thread::sleep は時間の型を取り、1500 * time.Millisecond や Duration::from_millis(1500) と書く。

Python に 1500 を渡すと約 25 分止まり、JavaScript に 1.5 を渡すとほとんど待たない(Java と C# は整数しか受けないのでコンパイルが通らない)。
言語を行き来するときは単位を確かめる。

Go で整数の変数に time.Second を掛けると型エラーになる

n := 2 のあとに time.Sleep(n * time.Second) と書くと、invalid operation: n * time.Second (mismatched types int and time.Duration) でコンパイルが通らなかった。
変数は time.Duration(n) * time.Second のように型を変換する。

定数なら 2 * time.Second と書ける。
単位を付けずに time.Sleep(2) と書くと、コンパイルは通るが 2 ナノ秒しか待たない。
実際に測ると 10 ミリ秒もかからず戻った。

Java の Thread.sleep は検査例外を投げる

main に throws を付けずに Thread.sleep(100) を呼ぶと、unreported exception InterruptedException; must be caught or declared to be thrown で javac が止まった。

throws InterruptedException を宣言するか、try/catch で受ける。
待っている最中に別のスレッドが interrupt を呼ぶとこの例外が出るので、握りつぶさずに処理を打ち切るか、割り込みの印を戻す書き方が望ましい。

JavaScript では待つ書き方をしないと先へ進む

setTimeout に関数を渡しただけだと、その行は待たずに次の行へ進む。
1 秒後に表示する処理を登録して直後に別の行を実行すると、直後の行のほうが先に表示された。

処理を止めて待ちたいときは、Promise を返す timers/promises の setTimeout を await する。
await は async 関数の中でしか使えない点にも注意する。

Atomics.wait を使うと Node.js のメインスレッドをそのまま止められるが、その間は他の処理も一切動かない。
通常は await を使う。