Programming-Idioms

(dorun (pmap f (range 1 1001)))

auto futures = std::vector<std::future<void>>{};
for (auto i = 1; i <= 1000; ++i)
{
	futures.emplace_back(std::async(f, i));
}

Parallel.For(1, 1001, f);

taskPool.amap!f(iota(1, 1001));

for (int i = 1; i <= 1000; i++) {
  Isolate.spawn(f,i);   
}

f = fn x -> x * :rand.uniform() end

tasks = Enum.map(1..1000, fn i ->
  Task.async(fn ->
    f.(i)
  end)
end)

results = Task.yield_many(tasks, :infinity)

# Optional, if you care for the result
IO.inspect Enum.map(results, fn {_, {:ok, val}} -> val end)

lists:foreach(fun(I) -> spawn(?MODULE, _f, [I]) end, lists:seq(1, 1000)).

  integer :: tasks, n, t, i
  tasks = 1000
  n = num_images()
  t = this_image()
  do i = t, tasks, n
     call f(i)
  end do
  sync all

for i := range 1_000 {
	go f(i)
}

mapM_ (forkIO . f) [1..1000]

for (let i = 1; i <= 1000; i++) setTimeout(() => f(i), 0);

final ExecutorService executor = Executors.newFixedThreadPool(NB_THREADS);
for (int i = 1; i <= 1000; i++) {
  executor.submit(() -> f(i));
}
executor.shutdown();

fun main() = runBlocking {
    repeat(1000) {
        launch {
            f(it)
        }
    }
}

type

TThreadF = class(TThread)
  i: Integer;
  constructor Create(const _i: Integer);
  procedure Execute; override;
end;

constructor TThreadF.Create(const _i: Integer);
begin
  i := _i;
  FreeOnTerminate := True;
  inherited Create(False);
end;

procedure TThreadF.Execute;
begin
  f(i);
end;

var i: Integer;

begin
  for i := 1 to 1000 do begin TThreadF.Create(i);
  ReadLn;
end.  

for my $i (1 .. 1000) {
    threads->create('f', $i);
}

pool = Pool()
for i in range(1, 1001):
	pool.apply_async(f, [i])

threads = 1000.times.map do |i|
  Thread.new { f(i) }
end
threads.join

(0..1000).into_par_iter().for_each(f);

let threads: Vec<_> = (0..1000).map(|i| {
	thread::spawn(move || f(i))
}).collect();

for thread in threads {
	thread.join();
}