Rendezvous: Difference between revisions

=={{header|Ada}}==

Ada has integrated [http://www.iuma.ulpgc.es/users/jmiranda/gnat-rts/node20.htm rendezvous support]. The caller calls to a rendezvous using the name of the task suffixed by the entry point name and the parameters. An entry point can be called using timed entry call statement which allow limit waiting time:

Server.Wake_Up (Parameters);

or delay 5.0;

-- No response, try something else

...

The task accepts a rendezvous using accept statement. The statement can contain body which implements the rendezvous. When several rendezvous need to be accepted a selective accept statement can be used. For example:

accept Wake_Up (Parameters : Work_Item) do

Current_Work_Item := Parameters;

or accept Shut_Down;

exit; -- Shut down requested

Entry points in the selective accept can be guarded by Boolean expressions which close the entry point when the expression yield false.

 

A task may requeue rendezvous request from the body of an accept statement to an entry point of the same or another task if the parameter profile of the entry point is compatible. The requeue statement may contain clause '''with abort'' which allows the caller to abort the request when it waits for other task to accept it. Without the clause the request is protected from abortion. This might be useful when the first task initiates processing of the request and the side effect of this action need to be removed when processing is completed.

===The task===

 

procedure Rendezvous is

begin

null;

Sample output:

<pre>

Mother Goose out of ink!

</pre>

=={{header|AutoHotkey}}==

SetTimer, print2, 400

 

Else

Return -1

=={{header|F_Sharp|F#}}==

 

It is possible to extract the boilerplate code into a reusable helper class which should be considered when using active objects a lot.

 

 

type PrinterCommand = Print of string

)).Start()

 

 

Example output:

2: And mounting its back,

Mother Goose out of ink!</pre>

 

=={{header|Go}}==

 

import (

"fmt"

"strings"

}

 

if ink == 0 {

}

for _, c := range line {

fmt.Printf("%c", c)

}

ink--

}

}

 

type rSync struct {

}

 

}

 

for {

data := <-entry.call

default:

}

}

}

 

break

}

}

busy.Done()

Output:

<pre>

Humpty Dumpty sat on a wall.

Humpty Dumpty had a great fall.

When she wanted to wander,

Jack's mother came in,

And caught the goose soon,

</pre>

 

=={{header|Oz}}==

 

First a simple printer class whose definition is completely orthogonal to multithreading issues:

class Printer

attr ink:5

end

end

Note how requeuing the task simply becomes delegation to a different object.

 

Active object are not a predefined abstraction in Oz. But due to Oz' first-class object messages, we can easily define it using ports and streams (many-to-one message passing):

Obj = {New Class Init}

MsgPort

{Wait Sync}

end

This functions takes a class and an initialization message and returns a procedure. When called, this procedure will send messages to the new object in a new thread and then wait for the <code>Sync</code> variable to become bound. Exceptions are propagated using [http://www.mozart-oz.org/home/doc/base/node13.html#label696 failed values].

 

 

With this new abstraction we can create the two printers and execute both print tasks in their own thread:

Reserve = {NewActiveSync Printer init(id:2)}

in

{System.showInfo " Mother Goose out of ink!"}

end

 

Example output:

Like in the rendezvous mechanism, parameters are not marshalled. This is because sharing immutable data between threads is safe.

In contrast to ADA, the parameters are buffered until the printer becomes ready. But with a synchronous communication mechanism, this should not cause problems.

 

=={{header|PicoLisp}}==

Rendezvous can be implemented in PicoLisp via the following function:

(when

(catch '(NIL)

(tell Pid 'setq 'Rendezvous (lit (eval Exe)))

NIL )

The caller invokes it in the callee via the

'[http://software-lab.de/doc/refT.html#tell tell]' interprocess communication,

 

Use case task:

(cond

((gt0 *Ink) (prinl *ID ": " Str) (dec '*Ink))

 

# Prepare to terminate all processes upon exit

Output:

<pre>1: Old Mother Goose

2: And mounting its back,

Humpty Dumpty: Out of Ink!</pre>

 

=={{header|Tcl}}==

<br>

{{works with|Tcl|8.6}}

package require Thread

 

# Wait enough time for the example to run and then finish

after 1000

 

{{omit from|E}} <!-- Not in the spirit of E concurrency; would be unenlightening to implement -->

{{omit from|JavaScript}} <!-- As yet, no multitasking unless you count setTimeout or multiple pages -->

{{omit from|PARI/GP|No concurrency or access to devices}}

{{omit from|Retro}} <!-- no concurrency in the standard implementations -->

==See also==

* [[wp:Rendezvous|Rendezvous]] on Wikipedia.