Concurrent computing: Difference between revisions

{{task|Concurrency}}

[[Category:Basic language learning]]

;Task:

 

 

=={{header|Ada}}==

 

procedure Concurrent_Hello is

begin

null; -- the "environment task" doesn't need to do anything

 

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));

echo("Code")

)

 

=={{header|Astro}}==

 

for word in words:

(word) |> async (w) =>

sleep(random())

 

{{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

PRINT str$[i]

NEXT

 

{{out}}

Rosetta</pre>

 

{{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)

PROC_killtimer(tID2%)

PROC_killtimer(tID3%)

 

=={{header|C}}==

#include <unistd.h>

#include <pthread.h>

pthread_mutex_t condm = PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int bang = 0;

#define WAITBANG() do { \

}

}

}

 

===With Threads===

}

===With Tasks===

{{works with|C sharp|7.1}}

using System.Threading.Tasks;

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);

}

===With a parallel loop===

using System.Threading.Tasks;

static void Main() => Parallel.ForEach(new[] {"Enjoy", "Rosetta", "Code"}, s => Console.WriteLine(s));

 

=={{header|C++}}==

{{works with|C++11}}

The following example compiles with GCC 4.7.

<code>g++ -std=c++11 -D_GLIBCXX_USE_NANOSLEEP -o concomp concomp.cpp</code>

#include <iostream>

#include <vector>

#include <random>

#include <chrono>

return 0;

 

=={{header|Cind}}==

 

execute() {

{# host.println("Enjoy");

# host.println("Code"); }

}

 

=={{header|Clojure}}==

 

A simple way to obtain concurrency is using the ''future'' function, which evaluates its body on a separate thread.

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,

 

=={{header|CoffeeScript}}==

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) ->

 

===Using Node.js===

As stated above, CoffeeScript is single-threaded. This approach launches multiple [http://nodejs.org Node.js] processes to achieve concurrency.

 

 

{ fork } = require 'child_process'

words = [ 'Enjoy', 'Rosetta', 'Code' ]

 

 

 

 

=={{header|Common Lisp}}==

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)

(bordeaux-threads:make-thread (writer "Enjoy"))

(bordeaux-threads:make-thread (writer "Rosetta"))

 

=={{header|D}}==

 

void main() {

s.writeln;

}

 

===Alternative version===

{{libheader|Tango}}

import tango.io.Console;

import tango.math.Random;

(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

 

main(){

code() => Future.delayed( Duration( milliseconds: rng.nextInt( 10 ) ), () => "Code");

 

===Isolate===

Using Isolates, similar to threads but each has its own memory, so they are more like Rust threads than C++

import 'dart:io' show exit, sleep;

import 'dart:math' show Random;

}

 

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

 

WaitForMultipleObjects(Length(lThreadArray), @lThreadArray, True, INFINITE);

 

=={{header|dodo0}}==

(

fork() -> return, throw

parprint("Code") ->

 

 

=={{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 <- (`

}

`) <- get(0) <- (string)

 

=={{header|EchoLisp}}==

(lib 'tasks) ;; use the tasks library

 

#task:id:67:running code

#task:id:65:running Enjoy

 

=={{header|Egel}}==

import "prelude.eg"

import "io.ego"

[_ -> print "rosetta\n"])

[_ -> print "code\n"] in nop

 

=={{header|Elixir}}==

def computing(xs) do

Enum.each(xs, fn x ->

end

 

{{out}}

=={{header|Erlang}}==

hw.erl

-export([start/0]).

 

_N -> wait(N-1)

end

 

running it

 

=={{header|Euphoria}}==

puts(1,s)

puts(1,'\n')

task_schedule(task3,1)

 

 

Output:

=={{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 } }

["Enjoy"; "Rosetta"; "Code";]

 

 

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}}==

 

 

=={{header|Forth}}==

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

 

s" Code" task

begin pause single-tasking? until ;

 

=={{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'

!$omp end parallel do

 

 

=={{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)

Print

Sleep

 

Sample output

Code

</pre>

 

=={{header|Go}}==

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 (

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 (

}

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"

}

}

Output:

<pre>

 

=={{header|Groovy}}==

Thread.start {

Thread.sleep(1000 * Math.random() as int)

println w

}

 

=={{header|Haskell}}==

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"

 

A more elaborated example using MVars and a random running time per thread.

 

import System.Random

 

-- until we write another value to it

putMVar v (s : val) -- append a text string to the MVar and block other

 

==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)

 

=={{header|J}}==

 

 

Rosetta

Code

 

=={{header|Java}}==

{{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

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();

This second block creates the workers, sends them a message and creates an event listener to handle the response.

var workers = [];

 

}, false);

workers[i].postMessage(words[i]);

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

function sleepprint(s)

@sync for word in words

@async sleepprint(word)

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.util.concurrent.CyclicBarrier

val barrier = CyclicBarrier(msgs.size)

for (msg in msgs) Thread(DelayedMessagePrinter(barrier, msg)).start()

 

{{out}}

 

=={{header|LFE}}==

;;;

;;; This is a straight port of the Erlang version.

(0 0)

(_n (wait (- n 1)))))))

 

=={{header|Logtalk}}==

Works when using SWI-Prolog, XSB, or YAP as the backend compiler.

 

:- initialization(output).

)).

 

 

=={{header|Lua}}==

co[1] = coroutine.create( function() print "Enjoy" end )

co[2] = coroutine.create( function() print "Rosetta" end )

i = i + 1

end

 

=={{header|M2000 Interpreter}}==

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.

 

Thread.Plan Concurrent

Module CheckIt {

CheckIt

 

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Parallelization requires Mathematica 7 or later

Pause[RandomReal[]];

Print[s],

{s, {"Enjoy", "Rosetta", "Code"}}

 

=={{header|Mercury}}==

:- interface.

 

spawn(io.print_cc("Enjoy\n"), !IO),

spawn(io.print_cc("Rosetta\n"), !IO),

 

=={{header|Neko}}==

Concurrent computing, in Neko

*/

 

/* Let the threads complete */

 

{{out}}

=={{header|Nim}}==

Compile with <code>nim --threads:on c concurrent</code>:

 

var thr: array[3, Thread[int32]]

for i in 0..thr.high:

createThread(thr[i], f, int32(i))

 

===OpenMP===

Compile with <code>nim --passC:"-fopenmp" --passL:"-fopenmp" c concurrent</code>:

 

for i in 0||2:

 

===Thread Pools===

Compile with <code>nim --threads:on c concurrent</code>:

const str = ["Enjoy", "Rosetta", "Code"]

 

echo str[i]

 

for i in 0..str.high:

spawn f(i)

 

=={{header|Objeck}}==

bundle Default {

class MyThread from Thread {

}

}

 

=={{header|OCaml}}==

 

#load "unix.cma"

#load "threads.cma"

let () =

Random.self_init ();

 

=={{header|Oforth}}==

Oforth uses tasks to implement concurrent computing. A task is scheduled using #& on a function, method, block, ...

 

#[ "Rosetta" 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|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,

call syssleep .5 -- add another sleep here

say text

 

=={{header|Oz}}==

The randomness comes from the unpredictability of thread scheduling (this is how I understand this exercise).

 

thread

{System.showInfo Msg}

end

end

 

=={{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]);

 

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()

{

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|Perl}}==

use Time::HiRes qw(sleep);

 

print shift, "\n";

}, $_)

 

Or using coroutines provided by {{libheader|Coro}}

use Coro;

use Coro::Timer qw( sleep );

} $_

} qw( Enjoy Rosetta Code );

 

=={{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.

 

=={{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

===Using child processes===

(let N (rand 1000 4000) # Randomize

(unless (fork) # Create child process

(wait N) # Wait 1 .. 4 sec

(println Str) # Print string

 

=={{header|Pike}}==

Using POSIX threads:

// Start threads and wait for them to finish

({

// Exit program

exit(0);

Output:

Enjoy

 

Using Pike's backend:

{

call_out(write, random(1.0), "Enjoy\n");

call_out(exit, 1, 0);

return -1; // return -1 starts the backend which makes Pike run until exit() is called.

Output:

Rosetta

=={{header|PowerShell}}==

Using Background Jobs:

 

$SB = {param($String)Write-Output $String}

 

Get-Job | Wait-Job | Receive-Job

 

Using .NET Runspaces:

 

$SB = {param($String)Write-Output $String}

$Pipeline.Dispose()

}

 

=={{header|Prolog}}==

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,[]),

Delay is random_float,

sleep(Delay),

 

=={{header|PureBasic}}==

 

Procedure Printer(*str)

EndIf

 

 

=={{header|Python}}==

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__':

=== threading.Thread ===

import threading

lock = threading.Lock()

def echo(s):

time.sleep(1e-2*random.random())

sys.stdout.write(s)

sys.stdout.write('\n')

for line in 'Enjoy Rosetta Code'.split():

=== multiprocessing ===

from multiprocessing import Pool

def main():

p = Pool()

p.map(print, 'Enjoy Rosetta Code'.split())

if __name__=="__main__":

 

=={{header|Racket}}==

 

Threads provide a simple API for concurrent programming.

#lang racket

(for ([str '("Enjoy" "Rosetta" "Code")])

(thread (λ () (displayln str))))

 

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.

(formerly Perl 6)

{{works with|Rakudo|2018.9}}

{{out}}

<pre>Code

 

=={{header|Raven}}==

 

thread talker

talker as a

talker as b

 

=={{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

end.each do |t|

t.join

 

=={{header|Rust}}==

{{libheader|rand}}

use std::thread;

use rand::thread_rng;

}

thread::sleep_ms(1000);

 

=={{header|Scala}}==

List("Enjoy", "Rosetta", "Code").map { x =>

Futures.future {

println(x)

}

 

=={{header|Scheme}}==

(lambda () (print "Rosetta"))

 

If your implementation doesn't provide parallel-execute, it can be implemented with [https://srfi.schemers.org/srfi-18/srfi-18.html SRFI-18].

(define (parallel-execute . thunks)

(let ((threads (map make-thread thunks)))

(for-each thread-start! threads)

 

=={{header|Sidef}}==

A very basic threading support is provided by the '''Block.fork()''' method:

 

a.map{|str|

say str

}.fork

 

{{out}}

Rosetta

</pre>

 

=={{header|Swift}}==

Using Grand Central Dispatch with concurrent queues.

 

let myList = ["Enjoy", "Rosetta", "Code"]

}

 

{{out}}

<pre>

=={{header|Standard ML}}==

Works with PolyML

structure TTm = Thread.Mutex ;

 

end ;

call

threadedStringList [ "Enjoy","Rosetta","Code" ];

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"}

 

will execute each line after a randomly chosen number (0...1000) of milliseconds.

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"}

 

(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 {

tpool::release $pool

after 1200 ;# Give threads time to do their work

 

=={{header|UnixPipes}}==

 

=={{header|VBA}}==

Three tasks scheduled for the same time with OnTime. The last scheduled task gets executed first.

Debug.Print "Enjoy"

End Sub

Application.OnTime when, "Rosetta"

Application.OnTime when, "Code"

 

=={{header|Visual Basic .NET}}==

 

 

Module Module1

End Sub

 

===Alternative version===

[https://tio.run/##TY9PC8IwDMXv@xRhpw60oODFm@gEQUWs4Llbg6t0zWjrn3362bmBvssjCfnl5VlMS3LYdbu6IRc8iNYHrPmlciiVtrfkQOphEAabJRC10TU4q2Dl4YgvOEurqGbZdyYeBRyktmPZ6ySdNAYN35LLZVmxNLd3auFMHkOQsCaFKReN0YGlkGaTHsL8D9BrCMSFQWxYPM6P@A5svsgyWEaC9WSQX50OuNcW/7fzmDQCh8ZYJL0PL3XdBw Try It Online!]

Module Module1

Dim rnd As New Random()

End Sub)

End Sub

{{out}}

<pre>Rosetta

Enjoy

Code</pre>

 

=={{header|Wren}}==

var words = ["Enjoy", "Rosetta", "Code"]

var rand = Random.new()

}

System.print()

 

=={{header|zkl}}==