Creating implementation for idiom 185 : Execute function in 30 seconds

Idiom

# 185 Execute function in 30 seconds

Created by

Lead paragraph

Schedule the execution of f(42) in 30 seconds.

New implementation

Language

Imports

Code

Documentation URL

Original attribution URL

Online runnable demo

Username

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations

(do (Thread/sleep 30000)
    (f 42))

using System;
using System.Threading.Tasks;

Task.Delay(TimeSpan.FromSeconds(30))
    .ContinueWith(_ => f(42));

Future.delayed(const Duration(seconds: 30), () => f(42));

Demo
Doc

import "time"

timer := time.AfterFunc(
	30*time.Second,
	func() {
		f(42)
	})

Demo
Doc

import "time"

go func() {
	time.Sleep(30 * time.Second)
	f(42)
}()

Demo
Doc

sleep(30*1000)
f(42)

Demo

let id = setTimeout(f, 30000, 42);

Demo
Doc

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
executorService.schedule(() -> _f(42), delayInSeconds, TimeUnit.SECONDS);

Doc
Origin

import static java.lang.Thread.sleep;

Thread t = new Thread(() -> {
    try {
        sleep(30_000);
        f(42);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
});
t.start();

sleep(30);
f(42);

Demo
Doc

LCL framework

procedure TForm1.Button1Click(Sender: TObject);
begin
  Timer := TTimer.Create(Self);
  Timer.Interval := 30*1000;
  Timer.OnTimer := @OnTimer;
end;

procedure TForm1.OnTimer(Sender: TObject);
begin
  f(42);
  Timer.Enabled := False;
end;

use threads;

my $thr = threads->create(sub { sleep(30); f(42); });
$thr->join()

use threads;

my $thr = threads->create(sub { sleep(30); f(42); });
$thr->detach();

local $SIG{ALRM} = sub { f(42) };
alarm 30;

import threading

timer = threading.Timer(30.0, f, args=(42,) ) 
timer.start()

Thread.new do
  sleep 30
  f(42)
end

use std::time::Duration;
use std::thread::sleep;

sleep(Duration::new(30, 0));
f(42);

Demo
Doc

use std::thread;
use std::time::Duration;

// 通信覆盖计算子函数
fn cover_calc(
    pos: &[f64],
    xg: &[[f64; 201]; 201],
    yg: &[[f64; 201]; 201],
    rho: &[[f64; 201]; 201],
    pt: f64,
    n_noise: f64,
    f: f64,
) -> (f64, f64, [[f64; 201]; 201]) {
    let mut sn

(f future: 30 "seconds" * 1000) value: 42.

Preview