Concurrent computing: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→Alternative version: Didn't need the .tasks import) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(55 intermediate revisions by 25 users not shown) | |||
Line 9:
=={{header|Ada}}==
<
procedure Concurrent_Hello is
Line 25:
begin
null; -- the "environment task" doesn't need to do anything
end Concurrent_Hello;</
Note that random generator object is local to each task. It cannot be accessed concurrently without mutual exclusion. In order to get different initial states of local generators Reset is called (see [http://www.adaic.org/resources/add_content/standards/05rm/html/RM-A-5-2.html ARM A.5.2]).
=={{header|ALGOL 68}}==
<
PROC echo = (STRING string)VOID:
printf(($gl$,string));
Line 38:
echo("Code")
)
)</
=={{header|APL}}==
{{works with|Dyalog APL}}
Dyalog APL supports the <code>&</code> operator, which runs a function on its own thread.
<syntaxhighlight lang="apl">{⎕←⍵}&¨'Enjoy' 'Rosetta' 'Code'</syntaxhighlight>
{{out}}
(Example)
<pre>Enjoy
Code
Rosetta</pre>
=={{header|Astro}}==
<
for word in words:
(word) |> async (w) =>
sleep(random())
print(w)</
=={{header|
==={{header|BaCon}}===
{{libheader|gomp}}
{{works with|OpenMP}}
BaCon is a BASIC-to-C compiler. Assuming GCC compiler in this demonstration. Based on the C OpenMP source.
<
' Specify compiler flag
Line 71 ⟶ 84:
PRINT str$[i]
NEXT
</syntaxhighlight>
{{out}}
Line 84 ⟶ 97:
Rosetta</pre>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
The BBC BASIC interpreter is single-threaded so the only way of achieving 'concurrency' (short of using assembler code) is to use timer events:
<
tID1% = FN_ontimer(100, PROCtask1, 1)
Line 117 ⟶ 130:
PROC_killtimer(tID2%)
PROC_killtimer(tID3%)
ENDPROC</
=={{header|C}}==
Line 124 ⟶ 137:
{{libheader|pthread}}
<
#include <unistd.h>
#include <pthread.h>
Line 179 ⟶ 192:
pthread_join(a[i], NULL);
}
}</
'''Note''': since threads are created one after another, it is likely that the execution of their code follows the order of creation. To make this less evident, I've added the ''bang'' idea using condition: the thread really executes their code once the gun bang is heard. Nonetheless, I still obtain the same order of creation (Enjoy, Rosetta, Code), and maybe it is because of the order locks are acquired. The only way to obtain randomness seems to be to add random wait in each thread (or wait for special cpu load condition)
Line 185 ⟶ 198:
===OpenMP===
Compile with <code>gcc -std=c99 -fopenmp</code>:
<
#include <omp.h>
Line 195 ⟶ 208:
printf("%s\n", str[i]);
return 0;
}</
=={{header|C sharp|C#}}==
===With Threads===
<syntaxhighlight lang="csharp">
static Random tRand = new Random();
static void Main(string[] args)
{
Thread t = new Thread(new ParameterizedThreadStart(WriteText));
t.Start("Enjoy");
t = new Thread(new ParameterizedThreadStart(WriteText));
t.Start("Rosetta");
t = new Thread(new ParameterizedThreadStart(WriteText));
t.Start("Code");
Console.ReadLine();
}
private static void WriteText(object p)
{
Thread.Sleep(tRand.Next(1000, 4000));
Console.WriteLine(p);
}
</syntaxhighlight>
An example result:
<pre>
Enjoy
Code
Rosetta
</pre>
===With Tasks===
{{works with|C sharp|7.1}}
<syntaxhighlight lang="csharp">using System;
using System.Threading.Tasks;
public class Program
{
static async Task Main() {
Task t1 = Task.Run(() => Console.WriteLine("Enjoy"));
Task t2 = Task.Run(() => Console.WriteLine("Rosetta"));
Task t3 = Task.Run(() => Console.WriteLine("Code"));
await Task.WhenAll(t1, t2, t3);
}
}</syntaxhighlight>
===With a parallel loop===
<syntaxhighlight lang="csharp">using System;
using System.Threading.Tasks;
public class Program
{
static void Main() => Parallel.ForEach(new[] {"Enjoy", "Rosetta", "Code"}, s => Console.WriteLine(s));
}</syntaxhighlight>
=={{header|C++}}==
Line 203 ⟶ 272:
<code>g++ -std=c++11 -D_GLIBCXX_USE_NANOSLEEP -o concomp concomp.cpp</code>
<
#include <iostream>
#include <vector>
Line 229 ⟶ 298:
return 0;
}</
Output:
Line 238 ⟶ 307:
{{libheader|Microsoft Parallel Patterns Library (PPL)}}
<
#include <ppl.h> // MSVC++
Line 257 ⟶ 326:
);
return 0;
}</
Output:
<pre>
Line 268 ⟶ 337:
</pre>
=={{header|
<syntaxhighlight lang="cind">
execute() {
{# host.println("Enjoy");
# host.println("Rosetta");
# host.println("Code"); }
}
</syntaxhighlight>
=={{header|Clojure}}==
A simple way to obtain concurrency is using the ''future'' function, which evaluates its body on a separate thread.
<
(future (println text)))</
Using the new (2013) ''core.async'' library, "go blocks" can execute asynchronously,
sharing threads from a pool. This works even in ClojureScript (the JavaScript target of Clojure)
on a single thread. The ''timeout'' call is there just to shuffle things up: note this delay doesn't block a thread.
<
(doseq [text ["Enjoy" "Rosetta" "Code"]]
(go
(<! (timeout (rand-int 1000))) ; wait a random fraction of a second,
(println text)))</
=={{header|CoffeeScript}}==
Line 345 ⟶ 368:
JavaScript, which CoffeeScript compiles to, is single-threaded. This approach launches multiple process to achieve concurrency on [http://nodejs.org Node.js]:
<
for word in [ 'Enjoy', 'Rosetta', 'Code' ]
exec "echo #{word}", (err, stdout) ->
console.log stdout</
===Using Node.js===
Line 355 ⟶ 378:
As stated above, CoffeeScript is single-threaded. This approach launches multiple [http://nodejs.org Node.js] processes to achieve concurrency.
<
{ fork } = require 'child_process'
Line 362 ⟶ 385:
words = [ 'Enjoy', 'Rosetta', 'Code' ]
fork child_name, [ word ] for word in words</
<
console.log process.argv[ 2 ]</
=={{header|Common Lisp}}==
Line 374 ⟶ 397:
Concurrency and threads are not part of the Common Lisp standard. However, most implementations provide some interface for concurrency. [http://common-lisp.net/project/bordeaux-threads/ Bordeaux Threads], used here, provides a compatibility layer for many implementations. (Binding <var>out</var> to <code>*standard-output*</code> before threads are created is needed as each thread gets its own binding for <code>*standard-output*</code>.)
<
(let ((lock (bordeaux-threads:make-lock)))
(flet ((writer (string)
Line 383 ⟶ 406:
(bordeaux-threads:make-thread (writer "Enjoy"))
(bordeaux-threads:make-thread (writer "Rosetta"))
(bordeaux-threads:make-thread (writer "Code")))))</
=={{header|Crystal}}==
Crystal requires the use of channels to ensure that the main fiber doesn't exit before any of the new fibers are done, since each fiber sleeping could return control to the main fiber.
<syntaxhighlight lang="ruby">require "channel"
require "fiber"
require "random"
done = Channel(Nil).new
"Enjoy Rosetta Code".split.map do |x|
spawn do
sleep Random.new.rand(0..500).milliseconds
puts x
done.send nil
end
end
3.times do
done.receive
end</syntaxhighlight>
=={{header|D}}==
<
void main() {
Line 393 ⟶ 436:
s.writeln;
}
}</
===Alternative version===
{{libheader|Tango}}
<
import tango.io.Console;
import tango.math.Random;
Line 405 ⟶ 448:
(new Thread( { Thread.sleep(Random.shared.next(1000) / 1000.0); Cout("Rosetta").newline; } )).start;
(new Thread( { Thread.sleep(Random.shared.next(1000) / 1000.0); Cout("Code").newline; } )).start;
}</
=={{header|Dart}}==
===Future===
Using Futures, called Promises in Javascript
<syntaxhighlight lang="javascript">import 'dart:math' show Random;
main(){
enjoy() .then( (e) => print(e) );
rosetta() .then( (r) => print(r) );
code() .then( (c) => print(c) );
}
// Create random number generator
var rng = Random();
// Each function returns a future that starts after a delay
// Like using setTimeout with a Promise in Javascript
enjoy() => Future.delayed( Duration( milliseconds: rng.nextInt( 10 ) ), () => "Enjoy");
rosetta() => Future.delayed( Duration( milliseconds: rng.nextInt( 10 ) ), () => "Rosetta");
code() => Future.delayed( Duration( milliseconds: rng.nextInt( 10 ) ), () => "Code");
</syntaxhighlight>
===Isolate===
Using Isolates, similar to threads but each has its own memory, so they are more like Rust threads than C++
<syntaxhighlight lang="javascript">import 'dart:isolate' show Isolate, ReceivePort;
import 'dart:io' show exit, sleep;
import 'dart:math' show Random;
main() {
// Create ReceivePort to receive done messages
// Called a channel in other languages
var receiver = ReceivePort();
// Create job counter
var job_count = 3;
// Create job pool
var jobs = [ enjoy, rosetta, code ];
// Create random number generator
var rng = Random();
for ( var job in jobs ) {
// Sleep for random duration up to half a second
var sleep_time = Duration( milliseconds: rng.nextInt( 500 ) );
// Spawn Isolate to do work
// When finished the second argument will be sent to the receiver via the SendPort specified in onExit
Isolate.spawn( job, sleep_time, onExit: receiver.sendPort );
}
// Do something in main isolate
print("from main isolate\n");
// Register a listener on the ReceivePort, it gets called whenver something is sent on its SendPort
// We'll ignore the message with _ because we don't care about the data, just the event
receiver.listen( (_) {
// Decrement job counter
job_count -= 1;
// If jobs are all finished
if ( job_count == 0 ) {
print("\nall jobs finished!");
exit(0);
}
});
}
enjoy ( duration ) {
sleep( duration ) ;
print("Enjoy");
}
rosetta ( duration ) {
sleep( duration );
print("Rosetta");
}
code ( duration ) {
sleep( duration );
print("Code");
}
</syntaxhighlight>
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 446 ⟶ 574:
WaitForMultipleObjects(Length(lThreadArray), @lThreadArray, True, INFINITE);
end.</
=={{header|dodo0}}==
<
(
fork() -> return, throw
Line 462 ⟶ 590:
parprint("Code") ->
exit()</
=={{header|E}}==
<
for string in ["Enjoy", "Rosetta", "Code"] {
timer <- whenPast(base + entropy.nextInt(1000), fn { println(string) })
}</
Nondeterminism from preemptive concurrency rather than a random number generator:
<
for string in ["Enjoy", "Rosetta", "Code"] {
seedVat <- (`
Line 480 ⟶ 608:
}
`) <- get(0) <- (string)
}</
=={{header|EchoLisp}}==
<
(lib 'tasks) ;; use the tasks library
Line 497 ⟶ 625:
#task:id:67:running code
#task:id:65:running Enjoy
</syntaxhighlight>
=={{header|Egel}}==
<syntaxhighlight lang="egel">
import "prelude.eg"
import "io.ego"
Line 511 ⟶ 639:
[_ -> print "rosetta\n"])
[_ -> print "code\n"] in nop
</syntaxhighlight>
=={{header|Elixir}}==
<
def computing(xs) do
Enum.each(xs, fn x ->
Line 526 ⟶ 654:
end
Concurrent.computing ["Enjoy", "Rosetta", "Code"]</
{{out}}
Line 537 ⟶ 665:
=={{header|Erlang}}==
hw.erl
<
-export([start/0]).
Line 555 ⟶ 683:
_N -> wait(N-1)
end
end.</
running it
<
|erl -run hw start -run init stop -noshell</
=={{header|Euphoria}}==
<
puts(1,s)
puts(1,'\n')
Line 578 ⟶ 706:
task_schedule(task3,1)
task_yield()</
Output:
Line 587 ⟶ 715:
=={{header|F_Sharp|F#}}==
We define a parallel version of <code>Seq.iter</code> by using asynchronous workflows:
<
let piter f xs =
seq { for x in xs -> async { f x } }
Line 598 ⟶ 726:
["Enjoy"; "Rosetta"; "Code";]
main()</
With version 4 of the .NET framework and F# PowerPack 2.0 installed, it is possible to use the predefined <code>PSeq.iter</code> instead.
=={{header|Factor}}==
<
{ "Enjoy" "Rosetta" "Code" } [ print ] parallel-each</
=={{header|Forth}}==
Line 611 ⟶ 739:
Many Forth implementations come with a simple cooperative task scheduler. Typically each task blocks on I/O or explicit use of the '''pause''' word. There is also a class of variables called "user" variables which contain task-specific data, such as the current base and stack pointers.
<
require random.fs
Line 627 ⟶ 755:
s" Code" task
begin pause single-tasking? until ;
main</
=={{header|Fortran}}==
Fortran doesn't have threads but there are several compilers that support OpenMP, e.g. gfortran and Intel. The following code has been tested with thw Intel 11.1 compiler on WinXP.
<
implicit none
character(len=*), parameter :: str1 = 'Enjoy'
Line 675 ⟶ 803:
!$omp end parallel do
end program concurrency</
=={{header|FreeBASIC}}==
<
' Compiled with -mt switch (to use threadsafe runtiume)
' The 'ThreadCall' functionality in FB is based internally on LibFFi (see [https://github.com/libffi/libffi/blob/master/LICENSE] for license)
Line 706 ⟶ 834:
Print
Sleep
Loop While Inkey <> Chr(27)</
Sample output
Line 722 ⟶ 850:
Code
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
long priority(2)
priority(0) = _dispatchPriorityDefault
priority(1) = _dispatchPriorityHigh
priority(2) = _dispatchPriorityLow
dispatchglobal , priority(rnd(3)-1)
NSLog(@"Enjoy")
dispatchend
dispatchglobal , priority(rnd(3)-1)
NSLog(@"Rosetta")
dispatchend
dispatchglobal , priority(rnd(3)-1)
NSLog(@"Code")
dispatchend
HandleEvents
</syntaxhighlight>
=={{header|Go}}==
Line 729 ⟶ 881:
This solution also shows a good practice for generating random numbers in concurrent goroutines. While certainly not needed for this RC task, in the more general case where you have a number of goroutines concurrently needing random numbers, the goroutines can suffer congestion if they compete heavily for the sole default library source. This can be relieved by having each goroutine create its own non-sharable source. Also particularly in cases where there might be a large number of concurrent goroutines, the source provided in subrepository rand package (exp/rand) can be a better choice than the standard library generator. The subrepo generator requires much less memory for "state" and is much faster to seed.
<
import (
Line 751 ⟶ 903:
fmt.Println(<-q)
}
}</
===Afterfunc===
time.Afterfunc combines the sleep and the goroutine start. log.Println serializes output in the case goroutines attempt to print concurrently. sync.WaitGroup is used directly as a checkpoint.
<
import (
Line 779 ⟶ 931:
}
q.Wait()
}</
===Select===
This solution might stretch the intent of the task a bit. It is concurrent but not parallel. Also it doesn't sleep and doesn't call the random number generator explicity. It works because the select statement is specified to make a "pseudo-random fair choice" among
multiple channel operations.
<
import "fmt"
Line 808 ⟶ 960:
}
}
}</
Output:
<pre>
Line 825 ⟶ 977:
=={{header|Groovy}}==
<
Thread.start {
Thread.sleep(1000 * Math.random() as int)
println w
}
}.each { it.join() }</
=={{header|Haskell}}==
Line 836 ⟶ 988:
Note how the map treats the list of processes just like any other data.
<
main = mapM_ forkIO [process1, process2, process3] where
process1 = putStrLn "Enjoy"
process2 = putStrLn "Rosetta"
process3 = putStrLn "Code"</
A more elaborated example using MVars and a random running time per thread.
<
import System.Random
Line 863 ⟶ 1,015:
-- until we write another value to it
putMVar v (s : val) -- append a text string to the MVar and block other
-- threads from writing to it unless it is read first</
==Icon and {{header|Unicon}}==
The following code uses features exclusive to Unicon
<
L:=[ thread write("Enjoy"), thread write("Rosetta"), thread write("Code") ]
every wait(!L)
end</
=={{header|J}}==
Using J's new threading primitives (in place of some sort of thread emulation):
<syntaxhighlight lang=J>reqthreads=: {{ 0&T.@''^:(0>.y-1 T.'')0 }}
dispatchwith=: (t.'')every
newmutex=: 10&T.
lock=: 11&T.
unlock=: 13&T.
synced=: {{
lock n
r=. u y
unlock n
r
}}
register=: {{ out=: out, y }} synced (newmutex 0)
task=: {{
reqthreads 3 NB. at least 3 worker threads
out=: EMPTY
#@> register dispatchwith ;:'Enjoy Rosetta Code'
out
}}</syntaxhighlight>
Sample use:
<syntaxhighlight lang=J> task''
Enjoy
Rosetta
Code
task''
Enjoy
Code
Rosetta</syntaxhighlight>
=={{header|Java}}==
Create a new <code>Thread</code> array, shuffle the array, start each thread.
<syntaxhighlight lang="java">
Thread[] threads = new Thread[3];
threads[0] = new Thread(() -> System.out.println("enjoy"));
threads[1] = new Thread(() -> System.out.println("rosetta"));
threads[2] = new Thread(() -> System.out.println("code"));
Collections.shuffle(Arrays.asList(threads));
for (Thread thread : threads)
thread.start();
</syntaxhighlight>
<br />
An alternate demonstration
{{works with|Java|1.5+}}
Uses CyclicBarrier to force all threads to wait until they're at the same point before executing the println, increasing the odds they'll print in a different order (otherwise, while the they may be executing in parallel, the threads are started sequentially and with such a short run-time, will usually output sequentially as well).
<
public class Threads
Line 925 ⟶ 1,106:
new Thread(new DelayedMessagePrinter(barrier, "Code")).start();
}
}</
=={{header|JavaScript}}==
JavaScript now enjoys access to a concurrency library thanks to [http://en.wikipedia.org/wiki/Web_worker Web Workers]. The Web Workers specification defines an API for spawning background scripts. This first code is the background script and should be in the concurrent_worker.js file.
<
self.postMessage(event.data);
self.close();
}, false);</
This second block creates the workers, sends them a message and creates an event listener to handle the response.
<
var workers = [];
Line 944 ⟶ 1,125:
}, false);
workers[i].postMessage(words[i]);
}</
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
function sleepprint(s)
Line 958 ⟶ 1,139:
@sync for word in words
@async sleepprint(word)
end</
=={{header|Kotlin}}==
{{trans|Java}}
<
import java.util.concurrent.CyclicBarrier
Line 977 ⟶ 1,158:
val barrier = CyclicBarrier(msgs.size)
for (msg in msgs) Thread(DelayedMessagePrinter(barrier, msg)).start()
}</
{{out}}
Line 988 ⟶ 1,169:
=={{header|LFE}}==
<
;;;
;;; This is a straight port of the Erlang version.
Line 1,015 ⟶ 1,196:
(0 0)
(_n (wait (- n 1)))))))
</syntaxhighlight>
=={{header|Logtalk}}==
Works when using SWI-Prolog, XSB, or YAP as the backend compiler.
<
:- initialization(output).
Line 1,030 ⟶ 1,211:
)).
:- end_object.</
=={{header|Lua}}==
<
co[1] = coroutine.create( function() print "Enjoy" end )
co[2] = coroutine.create( function() print "Rosetta" end )
Line 1,048 ⟶ 1,229:
i = i + 1
end
until i == 3</
=={{header|M2000 Interpreter}}==
Line 1,059 ⟶ 1,240:
Threads actually runs in Wait loop. We can use Main.Task as a loop which is thread also. Threads can be run when we wait for input in m2000 console, or for events from M2000 GUI forms, also. Events always run in sequential form.
<syntaxhighlight lang="m2000 interpreter">
Thread.Plan Concurrent
Module CheckIt {
Line 1,113 ⟶ 1,294:
CheckIt
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
Parallelization requires Mathematica 7 or later
<
Pause[RandomReal[]];
Print[s],
{s, {"Enjoy", "Rosetta", "Code"}}
]</
=={{header|Mercury}}==
<syntaxhighlight lang="text">:- module concurrent_computing.
:- interface.
Line 1,136 ⟶ 1,317:
spawn(io.print_cc("Enjoy\n"), !IO),
spawn(io.print_cc("Rosetta\n"), !IO),
spawn(io.print_cc("Code\n"), !IO).</
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/**
Concurrent computing, in Neko
*/
Line 1,172 ⟶ 1,353:
/* Let the threads complete */
sys_sleep(4);</
{{out}}
Line 1,188 ⟶ 1,369:
=={{header|Nim}}==
Compile with <code>nim --threads:on c concurrent</code>:
<
var thr: array[3, Thread[int32]]
Line 1,197 ⟶ 1,378:
for i in 0..thr.high:
createThread(thr[i], f, int32(i))
joinThreads(thr)</
===OpenMP===
Compile with <code>nim --passC:"-fopenmp" --passL:"-fopenmp" c concurrent</code>:
<
for i in 0||2:
echo str[i]</
===Thread Pools===
Compile with <code>nim --threads:on c concurrent</code>:
<
const str = ["Enjoy", "Rosetta", "Code"]
proc f(i: int) {.thread.} =
echo str[i]
for i in 0..str.high:
spawn f(i)
sync()</
=={{header|Objeck}}==
<
bundle Default {
class MyThread from Thread {
Line 1,247 ⟶ 1,428:
}
}
</syntaxhighlight>
=={{header|OCaml}}==
<
#load "unix.cma"
#load "threads.cma"
Line 1,264 ⟶ 1,445:
let () =
Random.self_init ();
List.iter (Thread.join) threads</
=={{header|Oforth}}==
Line 1,270 ⟶ 1,451:
Oforth uses tasks to implement concurrent computing. A task is scheduled using #& on a function, method, block, ...
<
#[ "Rosetta" println ] &
#[ "Code" println ] &</
mapParallel method can be used to map a runnable on each element of a collection and returns a collection of results. Here, we println the string and return string size.
<
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(import (otus random!))
(for-each (lambda (str)
(define timeout (rand! 999))
(async (lambda ()
(sleep timeout)
(print str))))
'("Enjoy" "Rosetta" "Code"))
</syntaxhighlight>
{{Out}}
<pre>Code
Enjoy
Rosetta
</pre>
=={{header|ooRexx}}==
<syntaxhighlight lang="oorexx">
-- this will launch 3 threads, with each thread given a message to print out.
-- I've added a stoplight to make each thread wait until given a go signal,
Line 1,314 ⟶ 1,512:
call syssleep .5 -- add another sleep here
say text
</syntaxhighlight>
=={{header|Oz}}==
The randomness comes from the unpredictability of thread scheduling (this is how I understand this exercise).
<
thread
{System.showInfo Msg}
end
end
</syntaxhighlight>
=={{header|PARI/GP}}==
Here is a GP implementation using the [http://pari.math.u-bordeaux.fr/cgi-bin/gitweb.cgi?p=pari.git;a=tree;h=refs/heads/bill-mt;hb=refs/heads/bill-mt bill-mt] branch:
<
func(n)=print(["Enjoy","Rosetta","Code"][n]);
parapply(func,[1..3]);</
This is a PARI implementation which uses <code>fork()</code> internally. Note that the [[#C|C]] solutions can be used instead if desired; this program demonstrates the native PARI capabilities instead.
For serious concurrency, see Appendix B of the User's Guide to the PARI Library which discusses a solution using [[wp:Thread-local storage|tls]] on [[wp:POSIX Threads|pthreads]]. (There are nontrivial issues with using PARI in this environment, do not attempt to blindly implement a [[#C|C]] solution.)
<
foo()
{
Line 1,351 ⟶ 1,549:
pari_printf("Rosetta\n");
}
}</
See also [http://pari.math.u-bordeaux1.fr/Events/PARI2012/talks/pareval.pdf Bill Allombert's slides on parallel programming in GP].
=={{header|Pascal}}==
{{trans|Delphi}} modified for linux. Using simple running thread-counter to circumvent WaitForMultipleObjects.<BR>
Output of difference of sleep time and true sleep time ( running with 0..1999 threads you see once a while 1)
<syntaxhighlight lang="pascal">program ConcurrentComputing;
{$IFdef FPC}
{$MODE DELPHI}
{$ELSE}
{$APPTYPE CONSOLE}
{$ENDIF}
uses
{$IFDEF UNIX}
cthreads,
{$ENDIF}
SysUtils, Classes;
type
TRandomThread = class(TThread)
private
FString: string;
T0 : Uint64;
protected
procedure Execute; override;
public
constructor Create(const aString: string); overload;
end;
const
MyStrings: array[0..2] of String = ('Enjoy ','Rosetta ','Code ');
var
gblRunThdCnt : LongWord = 0;
constructor TRandomThread.Create(const aString: string);
begin
inherited Create(False);
FreeOnTerminate := True;
FString := aString;
interlockedincrement(gblRunThdCnt);
end;
procedure TRandomThread.Execute;
var
i : NativeInt;
begin
i := Random(300);
T0 := GettickCount64;
Sleep(i);
//output of difference in time
Writeln(FString,i:4,GettickCount64-T0 -i:2);
interlockeddecrement(gblRunThdCnt);
end;
var
lThreadArray: Array[0..9] of THandle;
i : NativeInt;
begin
Randomize;
gblRunThdCnt := 0;
For i := low(lThreadArray) to High(lThreadArray) do
lThreadArray[i] := TRandomThread.Create(Format('%9s %4d',[myStrings[Random(3)],i])).Handle;
while gblRunThdCnt > 0 do
sleep(125);
end.</syntaxhighlight>
{{out}}
<pre>
Enjoy 4 16 0
Code 0 22 0
Code 1 32 0
Rosetta 7 117 0
Enjoy 2 137 0
Code 6 214 0
Code 5 252 0
Enjoy 3 299 0</pre>
=={{header|Perl}}==
<
use Time::HiRes qw(sleep);
Line 1,365 ⟶ 1,638:
print shift, "\n";
}, $_)
} qw(Enjoy Rosetta Code);</
Or using coroutines provided by {{libheader|Coro}}
<
use Coro;
use Coro::Timer qw( sleep );
Line 1,378 ⟶ 1,651:
} $_
} qw( Enjoy Rosetta Code );
</syntaxhighlight>
=={{header|Phix}}==
Without the sleep it is almost always Enjoy Rosetta Code, because create_thread() is more costly than echo(), as the former has to create a new call stack etc.<br>
The lock prevents the displays from mangling each other.
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (threads)</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">echo</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">sleep</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">enter_cs</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: #000000;">s</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;">'\n'</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">leave_cs</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">threads</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">create_thread</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">routine_id</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"echo"</span><span style="color: #0000FF;">),{</span><span style="color: #008000;">"Enjoy"</span><span style="color: #0000FF;">}),</span>
<span style="color: #000000;">create_thread</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">routine_id</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"echo"</span><span style="color: #0000FF;">),{</span><span style="color: #008000;">"Rosetta"</span><span style="color: #0000FF;">}),</span>
<span style="color: #000000;">create_thread</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">routine_id</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"echo"</span><span style="color: #0000FF;">),{</span><span style="color: #008000;">"Code"</span><span style="color: #0000FF;">})}</span>
<span style="color: #000000;">wait_thread</span><span style="color: #0000FF;">(</span><span style="color: #000000;">threads</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;">"done"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
=={{header|PicoLisp}}==
===Using background tasks===
<
(task (- N) (rand 1000 4000) # Random start time 1 .. 4 sec
Str Str # Closure with string value
(println Str) # Task body: Print the string
(task @) ) ) # and stop the task</
===Using child processes===
<
(let N (rand 1000 4000) # Randomize
(unless (fork) # Create child process
(wait N) # Wait 1 .. 4 sec
(println Str) # Print string
(bye) ) ) ) # Terminate child process</
=={{header|Pike}}==
Using POSIX threads:
<
// Start threads and wait for them to finish
({
Line 1,435 ⟶ 1,702:
// Exit program
exit(0);
}</
Output:
Enjoy
Line 1,442 ⟶ 1,709:
Using Pike's backend:
<
{
call_out(write, random(1.0), "Enjoy\n");
Line 1,449 ⟶ 1,716:
call_out(exit, 1, 0);
return -1; // return -1 starts the backend which makes Pike run until exit() is called.
}</
Output:
Rosetta
Line 1,457 ⟶ 1,724:
=={{header|PowerShell}}==
Using Background Jobs:
<
$SB = {param($String)Write-Output $String}
Line 1,466 ⟶ 1,733:
Get-Job | Wait-Job | Receive-Job
Get-Job | Remove-Job</
Using .NET Runspaces:
<
$SB = {param($String)Write-Output $String}
Line 1,484 ⟶ 1,751:
$Pipeline.Dispose()
}
$Pool.Close()</
=={{header|Prolog}}==
Line 1,492 ⟶ 1,759:
Create a separate thread for each word. Join the threads to make sure they complete before the program exits.
<
thread_create(say("Enjoy"),A,[]),
thread_create(say("Rosetta"),B,[]),
Line 1,503 ⟶ 1,770:
Delay is random_float,
sleep(Delay),
writeln(Message).</
=={{header|PureBasic}}==
<
Procedure Printer(*str)
Line 1,531 ⟶ 1,798:
EndIf
FreeMutex(mutex)</
=={{header|Python}}==
{{works with|Python|3.7}}
Using asyncio module (I know almost nothing about it, so feel free to improve it :-)):
<syntaxhighlight lang="python">import asyncio
async def print_(string: str) -> None:
print(string)
async def main():
strings = ['Enjoy', 'Rosetta', 'Code']
coroutines = map(print_, strings)
await asyncio.gather(*coroutines)
if __name__ == '__main__':
asyncio.run(main())</syntaxhighlight>
{{works with|Python|3.2}}
Using the new to Python 3.2 [http://docs.python.org/release/3.2/library/concurrent.futures.html concurrent.futures library] and choosing to use processes over threads; the example will use up to as many processes as your machine has cores. This doesn't however guarantee an order of sub-process results.
<
Type "help", "copyright", "credits" or "license" for more information.
>>> from concurrent import futures
Line 1,546 ⟶ 1,831:
Rosetta
Code
>>></
{{works with|Python|2.5}}
<
import random
Line 1,558 ⟶ 1,843:
threading.Timer(random.random(), echo, ("Enjoy",)).start()
threading.Timer(random.random(), echo, ("Rosetta",)).start()
threading.Timer(random.random(), echo, ("Code",)).start()</
Or, by using a for loop to start one thread per list entry, where our list is our set of source strings:
<
import random
Line 1,569 ⟶ 1,854:
for text in ["Enjoy", "Rosetta", "Code"]:
threading.Timer(random.random(), echo, (text,)).start()</
=== threading.Thread ===
<
import threading
Line 1,585 ⟶ 1,870:
for line in 'Enjoy Rosetta Code'.split():
threading.Thread(target=echo, args=(line,)).start()</
=== multiprocessing ===
{{works with|Python|2.6}}
<
from multiprocessing import Pool
Line 1,598 ⟶ 1,883:
if __name__=="__main__":
main()</
=== twisted ===
<
from twisted.internet import reactor, task, defer
from twisted.python.util import println
Line 1,609 ⟶ 1,894:
for line in 'Enjoy Rosetta Code'.split()])
d.addBoth(lambda _: reactor.stop())
reactor.run()</
=== gevent ===
<
import random
import gevent
Line 1,618 ⟶ 1,903:
delay = lambda: 1e-4*random.random()
gevent.joinall([gevent.spawn_later(delay(), print, line)
for line in 'Enjoy Rosetta Code'.split()])</
=={{header|Racket}}==
Threads provide a simple API for concurrent programming.
<
#lang racket
(for ([str '("Enjoy" "Rosetta" "Code")])
(thread (λ () (displayln str))))
</syntaxhighlight>
In addition to "thread" which is implemented as green threads (useful for IO etc), Racket has "futures" and "places" which are similar tools for using multiple OS cores.
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2018.9}}
<syntaxhighlight lang="raku" line>my @words = <Enjoy Rosetta Code>;
@words.race(:batch(1)).map: { sleep rand; say $_ };</syntaxhighlight>
{{out}}
<pre>Code
Rosetta
Enjoy</pre>
=={{header|Raven}}==
<
thread talker
Line 1,641 ⟶ 1,936:
talker as a
talker as b
talker as c</
=={{header|Rhope}}==
{{works with|Rhope|alpha 1}}
<
|:
Print["Enjoy"]
Print["Rosetta"]
Print["Code"]
:|</
In Rhope, expressions with no shared dependencies run in parallel by default.
=={{header|Ruby}}==
<
Thread.new do
sleep rand
Line 1,661 ⟶ 1,956:
end.each do |t|
t.join
end</
=={{header|Rust}}==
{{libheader|rand}}
<
use std::thread;
use rand::thread_rng;
Line 1,682 ⟶ 1,977:
}
thread::sleep_ms(1000);
}</
=={{header|Scala}}==
<
List("Enjoy", "Rosetta", "Code").map { x =>
Futures.future {
Line 1,691 ⟶ 1,986:
println(x)
}
}.foreach(_())</
=={{header|Scheme}}==
<
(lambda () (print "Rosetta"))
(lambda () (print "Code")))</
If your implementation doesn't provide parallel-execute, it can be implemented with [https://srfi.schemers.org/srfi-18/srfi-18.html SRFI-18].
<syntaxhighlight lang="scheme">(import (srfi 18))
(define (parallel-execute . thunks)
(let ((threads (map make-thread thunks)))
(for-each thread-start! threads)
(for-each thread-join! threads)))</syntaxhighlight>
=={{header|Sidef}}==
A very basic threading support is provided by the '''Block.fork()''' method:
<
a.map{|str|
Line 1,706 ⟶ 2,008:
say str
}.fork
}.map{|thr| thr.wait }</
{{out}}
Line 1,714 ⟶ 2,016:
Rosetta
</pre>
=={{header|Slope}}==
<syntaxhighlight lang="slope">(coeval
(display "Enjoy")
(display "Rosetta")
(display "Code"))</syntaxhighlight>
=={{header|Swift}}==
Using Grand Central Dispatch with concurrent queues.
<
let myList = ["Enjoy", "Rosetta", "Code"]
Line 1,727 ⟶ 2,035:
}
dispatch_main()</
{{out}}
<pre>
Line 1,734 ⟶ 2,042:
2015-02-05 10:15:01.831 rosettaconcurrency[1917:37904] Rosetta
</pre>
=={{header|Standard ML}}==
Works with PolyML
<syntaxhighlight lang="standard ml">structure TTd = Thread.Thread ;
structure TTm = Thread.Mutex ;
val threadedStringList = fn tasks:string list =>
let
val mx = TTm.mutex () ;
val taskstore = ref tasks ;
fun makeFastRand () = Real.rem (Time.toReal (Time.now ()),1.0)
val doTask = fn () =>
let
val mytask : string ref = ref "" ;
in
( TTm.lock mx ; mytask := hd ( !taskstore ) ; taskstore:= tl (!taskstore) ; TTm.unlock mx ;
Posix.Process.sleep (Time.fromReal (makeFastRand ())) ;
TTm.lock mx ; print ( !mytask ^ "\n") ; TTm.unlock mx ;
TTd.exit ()
)
end
in
List.tabulate ( length tasks , fn i => TTd.fork (doTask , []) )
end ;
</syntaxhighlight>
call
threadedStringList [ "Enjoy","Rosetta","Code" ];
Rosetta
Code
Enjoy
=={{header|Tcl}}==
Assuming that "random" means that we really want the words to appear in random (rather then "undefined" or "arbitrary") order:
<
after [expr int(1000*rand())] {puts "Rosetta"}
after [expr int(1000*rand())] {puts "Code"}</
will execute each line after a randomly chosen number (0...1000) of milliseconds.
Line 1,763 ⟶ 2,085:
A step towards "undefined" would be to use <tt>after idle</tt>, which is Tcl for "do this whenever you get around to it". Thus:
<
after idle {puts "Rosetta"}
after idle {puts "Code"}</
(While no particular order is guaranteed by the Tcl spec, the current implementations will all execute these in the order in which they were added to the idle queue).
It's also possible to use threads for this. Here we do this with the built-in thread-pool support:
<
set pool [tpool::create -initcmd {
proc delayPrint msg {
Line 1,782 ⟶ 2,104:
tpool::release $pool
after 1200 ;# Give threads time to do their work
exit</
=={{header|UnixPipes}}==
<
=={{header|VBA}}==
Three tasks scheduled for the same time with OnTime. The last scheduled task gets executed first.
<syntaxhighlight lang="vb">Private Sub Enjoy()
Debug.Print "Enjoy"
End Sub
Private Sub Rosetta()
Debug.Print "Rosetta"
End Sub
Private Sub Code()
Debug.Print "Code"
End Sub
Public Sub concurrent()
when = Now + TimeValue("00:00:01")
Application.OnTime when, "Enjoy"
Application.OnTime when, "Rosetta"
Application.OnTime when, "Code"
End Sub</syntaxhighlight>
=={{header|Visual Basic .NET}}==
<
Module Module1
Line 1,814 ⟶ 2,154:
End Sub
End Module</
===Alternative version===
[https://tio.run/##TY9PC8IwDMXv@xRhpw60oODFm@gEQUWs4Llbg6t0zWjrn3362bmBvssjCfnl5VlMS3LYdbu6IRc8iNYHrPmlciiVtrfkQOphEAabJRC10TU4q2Dl4YgvOEurqGbZdyYeBRyktmPZ6ySdNAYN35LLZVmxNLd3auFMHkOQsCaFKReN0YGlkGaTHsL8D9BrCMSFQWxYPM6P@A5svsgyWEaC9WSQX50OuNcW/7fzmDQCh8ZYJL0PL3XdBw Try It Online!]
<
Module Module1
Dim rnd As New Random()
Line 1,825 ⟶ 2,165:
End Sub)
End Sub
End Module</
{{out}}
<pre>Rosetta
Enjoy
Code</pre>
=={{header|V (Vlang)}}==
===Porting of Go code===
<syntaxhighlight lang="go">import time
import rand
import rand.pcg32
import rand.seed
fn main() {
words := ['Enjoy', 'Rosetta', 'Code']
seed_u64 := u64(time.now().unix_time_milli())
q := chan string{}
for i, w in words {
go fn (q chan string, w string, seed_u64 u64) {
mut rng := pcg32.PCG32RNG{}
time_seed := seed.time_seed_array(2)
seed_arr := [u32(seed_u64), u32(seed_u64 >> 32), time_seed[0], time_seed[1]]
rng.seed(seed_arr)
time.sleep(time.Duration(rng.i64n(1_000_000_000)))
q <- w
}(q, w, seed_u64 + u64(i))
}
for _ in 0 .. words.len {
println(<-q)
}
}</syntaxhighlight>
===Vlang Idiomatic version===
<syntaxhighlight lang="go">import time
import rand
import rand.pcg32
import rand.seed
fn main() {
words := ['Enjoy', 'Rosetta', 'Code']
mut threads := []thread{} // mutable array to hold the id of the thread
for w in words {
threads << go fn (w string) { // record the thread
mut rng := pcg32.PCG32RNG{}
time_seed := seed.time_seed_array(4) // the time derived array to seed the random generator
rng.seed(time_seed)
time.sleep(time.Duration(rng.i64n(1_000_000_000)))
println(w)
}(w)
}
threads.wait() // join the thread waiting. wait() is defined for threads and arrays of threads
}</syntaxhighlight>
{{out}}<pre>Code
Rosetta
Enjoy
Rosetta
Enjoy
Code</pre>
=={{header|Wren}}==
<syntaxhighlight lang="wren">import "random" for Random
var words = ["Enjoy", "Rosetta", "Code"]
var rand = Random.new()
for (h in 1..3) {
var fibers = List.filled(3, null)
for (i in 0..2) fibers[i] = Fiber.new { System.print(words[i]) }
var called = List.filled(3, false)
var j = 0
while (j < 3) {
var k = rand.int(3)
if (!called[k]) {
fibers[k].call()
called[k] = true
j = j + 1
}
}
System.print()
}</syntaxhighlight>
{{out}}
Sample run:
<pre>
Enjoy
Code
Rosetta
Code
Enjoy
Rosetta
Rosetta
Enjoy
Code
</pre>
=={{header|XPL0}}==
Works on Raspberry Pi using XPL0 version 3.2. Processes actually execute
simultaneously, one per CPU core (beyond single-core RPi-1). Lock is
necessary to enable one line to finish printing before another line starts.
<syntaxhighlight lang="xpl0">int Key, Process;
[Key:= SharedMem(4); \allocate 4 bytes of memory common to all processes
Process:= Fork(2); \start 2 child processes
case Process of
0: [Lock(Key); Text(0, "Enjoy"); CrLf(0); Unlock(Key)]; \parent process
1: [Lock(Key); Text(0, "Rosetta"); CrLf(0); Unlock(Key)]; \child process
2: [Lock(Key); Text(0, "Code"); CrLf(0); Unlock(Key)] \child process
other [Lock(Key); Text(0, "Error"); CrLf(0); Unlock(Key)];
Join(Process); \wait for all child processes to finish
]</syntaxhighlight>
{{out}}
<pre>
Code
Enjoy
Rosetta
</pre>
=={{header|zkl}}==
<
fcn{println("Rosetta")}.strand(); // co-op thread
fcn{println("Code")}.future(); // another thread type</
{{out}}
<pre>
|