Events: Difference between revisions
added Easylang
mNo edit summary |
(added Easylang) |
||
(19 intermediate revisions by 12 users not shown) | |||
Line 28:
The event interface:
<
procedure Signal;
procedure Reset;
Line 34:
private
Fired : Boolean := False;
end Event;</
The event implementation:
<
procedure Signal is
begin
Line 49:
null;
end Wait;
end Event;</
With the event defined above:
<
procedure Test_Events is
Line 68:
Put_Line ("Signal X");
X.Signal;
end Test_Events;</
Sample output:
<pre>
Line 77:
=={{header|AutoHotkey}}==
<
Return
Line 87:
F2:: ; external event: fire on F2 key press
TrayTip, external, f2 key pressed
Return</
=={{header|BASIC256}}==
{{trans|Gambas}}
<syntaxhighlight lang="basic256">
subroutine Timer1_Timer()
print hour; ":"; minute; ":"; second
end subroutine
</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de Gambas.
</pre>
=={{header|BBC BASIC}}==
Line 93 ⟶ 107:
===API===
This uses a Windows event object:
<
WAIT_TIMEOUT = 258
Line 109 ⟶ 123:
DEF PROCelapsed
SYS "SetEvent", hEvent%
ENDPROC</
===Native===
This uses a simple variable as a semaphore:
<
Event% = FALSE
Line 127 ⟶ 141:
DEF PROCelapsed
Event% = TRUE
ENDPROC</
=={{header|C}}==
Using pipe to communicate to <code>fork</code>ed child. Since child will be blocking trying to read the other end of the pipe, this can be used for synchronization.
<
#include <unistd.h>
Line 149 ⟶ 163:
}
return 0;
}</
=={{header|C sharp|C#}}==
<
using System.Timers;
Line 171 ⟶ 185:
((Timer)sender).Stop();
}
}</
Sample output:
<pre>10-11-2010 18:35:11
Line 178 ⟶ 192:
=={{header|Clojure}}==
{{trans|Go}}
<
(:require [clojure.core.async :refer [>! <! >!! <!! go chan]])
(:require [clj-time.core :as time])
Line 215 ⟶ 229:
; Invoke -main function
(-main)
</syntaxhighlight>
{{Output}}
<pre>
Line 224 ⟶ 238:
2016:10:18:07.94 : Event received by task: reset
</pre>
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 278 ⟶ 293:
end;
Readln;
end.</
Sample output:
<pre>
Line 286 ⟶ 301:
=={{header|E}}==
<
def [var fired, var firer] := Ref.promise()
Line 309 ⟶ 324:
return event
}</
The event object has this behavior: the return value of <code>.wait()</code> will be resolved after the time of the earliest <code>.signal()</code> for which there is no intervening <code>.reset()</code>.
<
{
Line 326 ⟶ 341:
})
println("[1] Waiting 1 second...")
}</
=={{header|EasyLang}}==
[https://easylang.dev/show/#cod=y89TKMnMTS3iUlBQyM0vS1UoSsxLyc9NU9BSMDQwQOWB1CRnFiXnpCoYgdhgjQqGXHpc+XlAzaXFqfEp+eV5cKMgQhVQuhJFux4XRLcBFwA= Run it]
<syntaxhighlight>
on timer
move randomf * 100 randomf * 100
circle 2
timer 1
.
on mouse_down
move mouse_x mouse_y
circle 2
.
timer 0
</syntaxhighlight>
=={{header|Elixir}}==
{{trans|Erlang}}
<
def log(msg) do
time = Time.utc_now |> to_string |> String.slice(0..7)
Line 357 ⟶ 389:
end
Events.main</
{{out}}
Line 370 ⟶ 402:
=={{header|Erlang}}==
Events can be implemented by using the selective receive expression and erlang's built in message passing. Here task waits for the message 'go' before it will continue.
<
-module(events).
-compile(export_all).
Line 393 ⟶ 425:
P ! go,
timer:sleep(100).
</syntaxhighlight>
'''Output:'''
<
66> events:main().
0: 0:57 => Program start
Line 403 ⟶ 435:
0: 0:58 => Task resumed
ok
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
{{trans|C#}}
<
open System.Timers
Line 421 ⟶ 453:
timer.Start()
ignore <| Console.ReadLine()
0</
=={{header|FreeBASIC}}==
{{trans|Gambas}}
<syntaxhighlight lang="freebasic">
Sub Timer1_Timer()
Print Time
End Sub
</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de Gambas.
</pre>
=={{header|FutureBasic}}==
Event timer fires every tenth of a second
<syntaxhighlight lang="futurebasic">
timerbegin, 0.1, YES
cls : printf @"%@", time(@"h:mm:ss a zzz")
timerend
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
4:44:36 PM EDT
</pre>
=={{header|Gambas}}==
<
Print Str(Time(Now))
End</
Output:
<pre>
Line 443 ⟶ 503:
=={{header|Go}}==
A Go channel can represent an manual-reset event, as described by the task. The two states of signaled and reset correspond to the presence or absence of a value on the channel. The program signals by sending a value on the channel. The event is reset when the waiting task explicitly executes the channel receive operation, <-event.
<
import (
Line 465 ⟶ 525:
event <- 0
time.Sleep(100 * time.Millisecond)
}</
{{out}}
<pre>
Line 476 ⟶ 536:
=={{header|Haskell}}==
<
import Control.Concurrent.SampleVar
Line 486 ⟶ 546:
signalEvent (Event sv) = writeSampleVar sv ()
resetEvent (Event sv) = emptySampleVar sv
waitEvent (Event sv) = readSampleVar sv</
<
forkIO (waitTask e)
putStrLn "[1] Waiting 1 second..."
Line 497 ⟶ 557:
waitTask e = do putStrLn "[2] Waiting for event..."
waitEvent e
putStrLn "[2] Received event."</
Note: Because there is no serialization of the text output, there is a chance that it will appear interleaved.
Line 504 ⟶ 564:
The following only works in Unicon. The example illustrates the multiple tasks can
receive the same event:
<
procedure main()
Line 523 ⟶ 583:
signal(event.cond,0)
every wait(t1|t2)
end</
Sample run:
Line 535 ⟶ 595:
->
</pre>
=={{header|JavaScript}}==
An example using the [[wp:Yahoo!_UI_Library|YUI]] library:
<syntaxhighlight lang="javascript">YUI().use('event-custom', function(Y) {
// add a custom event:
Y.on('my:event', function () {
alert("Event fired");
});
// fire the event after one second:
setTimeout(function () {
Y.fire('my:event');
}, 1000);
});</syntaxhighlight>
An example simulating [[wp:Document_Object_Model|DOM]] events:
<syntaxhighlight lang="javascript">YUI().use('node-event-simulate', function(Y) {
// add a click event handler to a DOM node with id "button":
Y.one("#button").on("click", function (e) {
alert("Button clicked");
});
// simulate the click after one second:
setTimeout(function () {
Y.one("#button").simulate("click");
}, 1000);
});</syntaxhighlight>
=={{header|Julia}}==
Julia provides a variety of high and low level functions and macros for
The code below uses a Condition() event semaphore created in the base thread for communication
between two child threads.
<
function dolongcomputation(cond)
det(rand(4000, 4000))
Line 562 ⟶ 646:
sleep(5)
println("Done sleeping.")
</syntaxhighlight>
{{output}}<pre>
Starting task, sleeping...
Line 575 ⟶ 659:
Paste in the REPL:
<
(defun log (msg)
(let ((`#(,h ,m ,s) (erlang:time)))
Line 595 ⟶ 679:
(! pid 'go)
(timer:sleep 100))))
</syntaxhighlight>
Usage:
Line 614 ⟶ 698:
To catch an event, a corresponding event handler - a function with a predefined name - has to be definined in the code. Examples for such event handlers are:
<
on closeWindow
...
Line 622 ⟶ 706:
on mouseDown
...
end</
Also "Sprites" (visual elements) receive events by setting up such event handlers in scripts attached to them. Both predefined and custom events can be sent programmatically to sprites, e.g. using:
<
sendSprite(1, #mouseDown)
Line 631 ⟶ 715:
-- send custom event #fooBar to all existing sprites
sendAllSprites(#fooBar)</
Using a binary plugin ("Xtra"), in Windows also lower level window messages can be both sent and received:
{{libheader|Msg Xtra}}
<
-- send message WM_LBUTTONDOWN to a specific window identified by HWND hwnd
Line 649 ⟶ 733:
WM_COPYDATA = 74
WM_MOUSEWHEEL = 522
mx.msg_listen([WM_COPYDATA, WM_MOUSEWHEEL], VOID, #msgReceived)</
=={{header|
Mathematica supports events from timers (via Pause[]), task schedule descriptors. This will print a message after 4 seconds, then terminate the program.
<
->Will exit in 4 seconds</
=={{header|Nim}}==
{{trans|C}}
<
var p: array[2, cint]
Line 691 ⟶ 751:
discard p[1].write(addr p[0], 1)
var x: cint = 0
discard wait (addr x)
else:
discard close p[1]
discard p[0].read(addr p[1], 1)
echo "received signal from pipe"</
===Stdlib Semaphore===
This version using locks module for signaling the condition.
<syntaxhighlight lang="nim">import locks
from os import sleep
import times
from strformat import fmt
var
# condition variable which shared across threads
cond: Cond
lock: Lock
threadproc: Thread[void]
proc waiting {.thread.} =
echo "spawned waiting proc"
let start = getTime()
cond.wait lock
echo fmt"thread ended after waiting {getTime() - start}."
proc main =
initCond cond
initLock lock
threadproc.createThread waiting
echo "in main proc"
os.sleep 1000
echo "send signal/event notification"
signal cond
joinThread threadproc
deinitCond cond
deinitLock lock
main()</syntaxhighlight>
Compile and run: <pre>nim c -r --threads:on events_cond.nim</pre>
{{out}}
<pre>in main proc
spawned waiting proc
send signal/event notification
thread ended after waiting 1 second, 61 microseconds, and 311 nanoseconds.</pre>
=={{header|Oforth}}==
Line 702 ⟶ 802:
An event is often implemented with a control channel. A task is waiting for an object on the channel. When the event occurs, another task sends an object on this channel.
<
| ch |
Channel new ->ch
#[ ch receive "Ok, event is signaled !" println ] &
System sleep(1000)
ch send($myEvent) ;</
An emitter is a general implementation for handling events : an emitter waits for events emitted and launches listeners that are waiting for those events.
<
: anEvent2
Line 720 ⟶ 820:
$myEvent e emit
]
e close ;</
=={{header|Oz}}==
{{trans|Haskell}}
Events can be implemented as mutable references to dataflow variables:
<
fun {NewEvent}
{NewCell _}
Line 753 ⟶ 853:
{Delay 1000}
{System.showInfo "[1] Signaling event."}
{SignalEvent E}</
However, this code is quite unidiomatic. If we need to wait for an event just once (like in this example), we can simply use a dataflow variable, i.e. an event that cannot be reset:
<
E
in
Line 767 ⟶ 867:
{Delay 1000}
{System.showInfo "[1] Signaling event."}
E = unit</
If we want to synchronize two threads repeatedly and exchange data, it is natural to use ports and streams. Streams are just lists with an unbound tail. A port is basically a pointer to the tail of a list, i.e. it keeps track of where the next event can be written to:
<
MyPort
in
Line 788 ⟶ 888:
{System.showInfo "[1] Signaling event."}
{Port.send MyPort unit}
end</
It is important to limit the scope of a stream as much as possible to ensure that the already read part of the stream is garbage-collected.
Line 794 ⟶ 894:
This is an example of using the [http://search.cpan.org/perldoc?AnyEvent AnyEvent] module.
The result is this: it prints "Hello world!" after one second, then after another second prints "Hi!" four times every quarter of a second and then immediately prints "Bye!" and quits:
<
# a new condition with a callback:
Line 824 ⟶ 924:
# wait for the $quit condition to be ready:
$quit->recv();</
This is the same using AnyEvent [http://search.cpan.org/perldoc?AE simplified API]:
<
my $quit = AE::cv sub { warn "Bye!\n" };
Line 840 ⟶ 940:
};
$quit->recv;</
=={{header|
The primary synchronisation primitive in phix is the critical section, in the following the leave_cs()
in main() acts as signalling an event, and the one in echo() from whichever goes first acts to signal
that the other can/should resume.
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">lock</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">init_cs</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">timedate</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">showtime</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;">format_timedate</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">date</span><span style="color: #0000FF;">(),</span><span style="color: #008000;">" h:m:s\n"</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</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;">rnd</span><span style="color: #0000FF;">()/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- see note</span>
<span style="color: #7060A8;">enter_cs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lock</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;">sleep</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">showtime</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">leave_cs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lock</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">enter_cs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lock</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</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;">"job1"</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;">"job2"</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;">"main"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">showtime</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">sleep</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</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;">"free"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">showtime</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">leave_cs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lock</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\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
{{out}}
Typically the first thread to attempt enter_cs() is released first, but there is
no guarantee of that. The sleep(rnd()/10) above evens out the likelihood, by
pausing for up to 0.1s, but otherwise isn't necessary.
<pre>
main 10:00:57
free 10:00:58
job2 10:00:59
job1 10:01:00
done
</pre>
External events such as timers and user input are handled in pGUI, eg
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">function</span> <span style="color: #000000;">timer_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000080;font-style:italic;">/*ih*/</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">IupUpdate</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #004600;">IUP_IGNORE</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #004080;">Ihandle</span> <span style="color: #000000;">timer</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupTimer</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"timer_cb"</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">1000</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">key_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000080;font-style:italic;">/*ih*/</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">=</span><span style="color: #004600;">K_ESC</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #004600;">IUP_CLOSE</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">=</span><span style="color: #004600;">K_F5</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">iteration</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #7060A8;">IupSetInt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">timer</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"RUN"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (restart timer)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">return</span> <span style="color: #004600;">IUP_CONTINUE</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #7060A8;">IupSetCallback</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"K_ANY"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"key_cb"</span><span style="color: #0000FF;">))</span>
<!--</syntaxhighlight>-->
=={{header|PicoLisp}}==
Line 875 ⟶ 1,018:
This will print a message after one second, then terminate the program after
another four seconds:
<
(prinl "Exit in 4 seconds")
(alarm 4 (bye)) )</
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
$timer = New-Object -TypeName System.Timers.Timer -Property @{Enabled=$true; Interval=1000; AutoReset=$true}
Line 897 ⟶ 1,040:
$global:counter = 0
& $job.Module {$global:counter}
</syntaxhighlight>
{{Out}}
<pre>
Line 909 ⟶ 1,052:
=={{header|PureBasic}}==
<
ButtonGadget (1, 10, 10, 35, 20, "Quit")
Line 920 ⟶ 1,063:
EndIf
ForEver</
=={{header|Python}}==
<syntaxhighlight lang="python">
import threading
import time
def wait_for_event(event):
event.wait()
print("Thread: Got event")
e = threading.Event()
t = threading.Thread(target=wait_for_event, args=(e,))
t.start()
print("Main: Waiting one second")
time.sleep(1.0)
print("Main: Setting event")
e.set()
time.sleep(1.0)
print("Main: Done")
t.join()
</syntaxhighlight>
=={{header|Racket}}==
Line 931 ⟶ 1,099:
the task (since it's a useless value):
<
#lang racket
Line 940 ⟶ 1,108:
(void (sync task)) ; wait for the task to be done before exiting
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{trans|Go}}
<syntaxhighlight lang="raku" line>note now, " program start";
my $event = Channel.new;
my $todo = start {
note now, " task start";
$event.receive;
note now, " event reset by task";
}
note now, " program sleeping";
sleep 1;
note now, " program signaling event";
$event.send(0);
await $todo;</syntaxhighlight>
{{out}}
<pre>Instant:1403880984.089974 program start
Instant:1403880984.095400 program sleeping
Instant:1403880984.095491 task start
Instant:1403880985.099381 program signaling event
Instant:1403880985.109395 event reset by task</pre>
See also [[Handle_a_signal#Raku]] for an example of using Supplies to do reactive programming based on events (Unix signals in this case).
=={{header|REXX}}==
Although REXX can be event driven, most events would probably have to be actively checked to see if the event occurs.
<br>Here is a ''time-driven'' example of events happening, based on specific timer ticks.
<
signal on halt /*allow
parse arg timeEvent /*allow the "event" to be specified. */
if timeEvent='' then timeEvent=
event?: do forever /*determine if an event has occurred. */
theEvent= right(time(), 1)
if pos(theEvent, timeEvent)
end /*forever*/
say 'Control should never get here!' /*This is a logic can─never─happen ! */
halt: say '════════════ program halted.';
/*──────────────────────────────────────────────────────────────────────────────────────*/
happening: say 'an event occurred at' time()", the event is:" theEvent
do
nop /*replace NOP with the "process" code.*/
end /*while*/ /*NOP
<pre>
an event occurred at 16:13:29, the event is: 9
Line 983 ⟶ 1,177:
════════════ program halted.
</pre>
=={{header|Rust}}==
Rust ensures memory safety at compile-time without needing a garbage collector or runtime. There are several concurrency primitives in it's standard library.
<syntaxhighlight lang="rust">
use std::{sync::mpsc, thread, time::Duration};
fn main() -> Result<(), Box<dyn std::error::Error>> {
println!("[1] Starting");
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
println!("[2] Waiting for event");
rx.recv();
println!("[2] Received event");
});
thread::sleep(Duration::from_secs(1));
println!("[1] Sending event");
tx.send(())?;
thread::sleep(Duration::from_secs(1));
Ok(())
}
</syntaxhighlight>
=={{header|Tcl}}==
Tcl has been event-driven since 7.5, but only supported channel and timer events (plus variable traces, which can be used to create event-like entitites). With the addition of coroutines, it becomes much simpler to create general events:
{{works with|Tcl|8.6}}
<
proc pause ms {
after $ms [info coroutine];yield
Line 1,040 ⟶ 1,258:
X signal
}
waitForTasksToFinish</
Output:
<pre>waiting for event
Line 1,046 ⟶ 1,264:
received event</pre>
Of course, the classic way of writing this is much shorter, but intermingles the tasks:
<
puts "waiting for event"
vwait X
puts "received event"</
=={{header|Wren}}==
Wren-cli supports the scheduling of tasks using a timer.
The tasks to be executed are added to a list by the Scheduler class. The Timer.sleep method suspends the current fiber and signals the scheduler (by calling a private method) to execute the tasks one by one in their own fibers - in Wren only one fiber can execute at a time. The task results are then available to the main fiber on its resumption after Timer.sleep has completed.
<syntaxhighlight lang="wren">import "scheduler" for Scheduler
import "timer" for Timer
var a = 3
// add a task
Scheduler.add {
a = a * a
}
// add another task
Scheduler.add {
a = a + 1
}
System.print(a) // still 3
Timer.sleep(3000) // wait 3 seconds
System.print(a) // now 3 * 3 + 1 = 10</syntaxhighlight>
{{out}}
<pre>
3
10
</pre>
=={{header|Yabasic}}==
{{trans|Gambas}}
<syntaxhighlight lang="yabasic">
sub Timer1_Timer()
print Time$
end sub
</syntaxhighlight>
=={{header|zkl}}==
zkl provides an Atomics library for things like this. Events are async, waiting for an event doesn't poll.
<
// create thread waiting for event
fcn(event){event.wait(); println(vm," ping!")}.launch(event);
Atomic.sleep(1);
event.set();
println("done")</
{{out}}
<pre>
|