Concurrent computing: Difference between revisions

 

 

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

)

 

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

{{libheader|pthread}}

 

#include <unistd.h>

#include <pthread.h>

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)

===OpenMP===

Compile with <code>gcc -std=c99 -fopenmp</code>:

#include <omp.h>

 

printf("%s\n", str[i]);

return 0;

 

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

{{libheader|Microsoft Parallel Patterns Library (PPL)}}

 

#include <ppl.h> // MSVC++

 

);

return 0;

Output:

<pre>

</pre>

 

 

}

 

=={{header|Clojure}}==

 

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

 

=={{header|CoffeeScript}}==

 

 

exec "echo #{word}", (err, stdout) ->

 

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

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

===Channel===

 

import (

"fmt"

"time"

)

func main() {

words := []string{"Enjoy", "Rosetta", "Code"}

q := make(chan string)

q <- w

}

for i := 0; i < len(words); i++ {

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

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

 

:- initialization(output).

)).

 

 

=={{header|Lua}}==

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

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

i = i + 1

end

 

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

bundle Default {

class MyThread from Thread {

}

}

 

=={{header|OCaml}}==

#load "unix.cma"

#load "threads.cma"

let sleepy_print msg =

 

 

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

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

Code

Enjoy

 

=={{header|PureBasic}}==

 

EndProcedure

 

If OpenConsole()

EndIf

 

 

=={{header|Python}}==

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

Rosetta

Code

 

{{works with|Python|2.5}}

 

import random

threading.Timer(random.random(), echo, ("Enjoy",)).start()

threading.Timer(random.random(), echo, ("Rosetta",)).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

 

 

for text in ["Enjoy", "Rosetta", "Code"]:

 

=== threading.Thread ===

import threading

 

 

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

 

=== multiprocessing ===

 

{{works with|Python|2.6}}

from multiprocessing import Pool

 

 

if __name__=="__main__":

 

=== twisted ===

from twisted.internet import reactor, task, defer

from twisted.python.util import println

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

d.addBoth(lambda _: reactor.stop())

 

=== gevent ===

import random

import gevent

delay = lambda: 1e-4*random.random()

gevent.joinall([gevent.spawn_later(delay(), print, line)

 

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

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

Futures.future {

println(x)

}

 

=={{header|Scheme}}==

(lambda () (print "Rosetta"))

 

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

 

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|Visual Basic .NET}}==

 

 

Module Module1

End Sub

 

 

{{omit from|Maxima}}