49 mzlib/thread

▼ |  | Mz Lib: Legacy Racket Libraries

1 | mzlib/ a-signature
2 | mzlib/ a-unit
3 | mzlib/ async-channel
4 | mzlib/ awk
5 | mzlib/ class
6 | mzlib/ class100
7 | mzlib/ cm
8 | mzlib/ cm-accomplice
9 | mzlib/ cmdline
10 | mzlib/ cml
11 | mzlib/ compat
12 | mzlib/ compile
13 | mzlib/ contract
14 | mzlib/ control
15 | mzlib/ date
16 | mzlib/ deflate
17 | mzlib/ defmacro
18 | mzlib/ etc
19 | mzlib/ file
20 | mzlib/ for
21 | mzlib/ foreign
22 | mzlib/ include
23 | mzlib/ inflate
24 | mzlib/ integer-set
25 | mzlib/ kw
26 | mzlib/ list
27 | mzlib/ match
28 | mzlib/ math
29 | mzlib/ md5
30 | mzlib/ os
31 | mzlib/ pconvert
32 | mzlib/ pconvert-prop
33 | mzlib/ plt-match
34 | mzlib/ port
35 | mzlib/ pregexp
36 | mzlib/ pretty
37 | mzlib/ process
38 | mzlib/ restart
39 | mzlib/ runtime-path
40 | mzlib/ sandbox
41 | mzlib/ sendevent
42 | mzlib/ serialize
43 | mzlib/ shared
44 | mzlib/ string
45 | mzlib/ struct
46 | mzlib/ stxparam
47 | mzlib/ surrogate
48 | mzlib/ tar
49 | mzlib/ thread
50 | mzlib/ trace
51 | mzlib/ traceld
52 | mzlib/ trait
53 | mzlib/ transcr
54 | mzlib/ unit
55 | mzlib/ unit-exptime
56 | mzlib/ unit200
57 | mzlib/ unitsig200
58 | mzlib/ zip
| Bibliography
| Index

On this page:

coroutine
coroutine?
coroutine-run
coroutine-result
coroutine-kill
consumer-thread
run-server

top← prev up next →

( require mzlib/thread)

( coroutine proc) → coroutine?
proc : (( any/c . -> . void?) . -> . any/c)

Returns a coroutine object to encapsulate a thread that runs only when allowed. The proc procedure should accept one argument, and proc is run in the coroutine thread when coroutine-run is called. If coroutine-run returns due to a timeout, then the coroutine thread is suspended until a future call to coroutine-run. Thus, proc only executes during the dynamic extent of a coroutine-run call.

The argument to proc is a procedure that takes a boolean, and it can be used to disable suspends (in case proc has critical regions where it should not be suspended). A true value passed to the procedure enables suspends, and #f disables suspends. Initially, suspends are allowed.

( coroutine? v) → any
v : any/c

Returns #t if v is a coroutine produced by coroutine, #f otherwise.

( coroutine-run until coroutine) → boolean?
until : ( or/c evt? real?)
coroutine : coroutine?

Allows the thread associated with coroutine to execute for up as long as until milliseconds (of until is a real number) or until is ready (if until is an event). If coroutine’s procedure disables suspends, then the coroutine can run arbitrarily long until it re-enables suspends.

The coroutine-run procedure returns #t if coroutine’s procedure completes (or if it completed earlier), and the result is available via coroutine-result. The coroutine-run procedure returns #f if coroutine’s procedure does not complete before it is suspended after timeout-secs. If coroutine’s procedure raises an exception, then it is re-raised by coroutine-run.

( coroutine-result coroutine) → any
coroutine : coroutine

Returns the result for coroutine if it has completed with a value (as opposed to an exception), #f otherwise.

( coroutine-kill coroutine) → void?
coroutine : coroutine?

Forcibly terminates the thread associated with coroutine if it is still running, leaving the coroutine result unchanged.

( consumer-thread f [init])

→

thread? |  | procedure?

f : procedure?
init : (-> any) = void

Returns two values: a thread descriptor for a new thread, and a procedure with the same arity as f.

When the returned procedure is applied, its arguments are queued to be passed on to f, and #<void> is immediately returned. The thread created by consumer-thread dequeues arguments and applies f to them, removing a new set of arguments from the queue only when the previous application of f has completed; if f escapes from a normal return (via an exception or a continuation), the f-applying thread terminates.

The init argument is a procedure of no arguments; if it is provided, init is called in the new thread immediately after the thread is created.

( run-server |  | port-no |  |  |  |
|  | conn-proc |  |  |  |
|  | conn-timeout |  |  |  |
| [ | handler |  |  |  |
|  | listen |  |  |  |
|  | close |  |  |  |
|  | accept |  |  |  |
|  | accept/break]) |  | → |  | void?

port-no : ( integer-in 1 65535)
conn-proc : ( input-port? output-port? . -> . any)
conn-timeout : ( and/c real? ( not/c negative?))
handler : ( exn? . -> . any/c) = void

listen

:

(( integer-in 1 65535) ( one-of/c 5) ( one-of/c #t)
. -> . listener?)

|  |  | = |  | tcp-listen

close : (listener? . -> . any) = tcp-close

| accept |  | : |  | (listener? . ->* . ( input-port? output-port?))
|  |  | = |  | tcp-accept

| accept/break |  | : |  | (listener? . ->* . ( input-port? output-port?))
|  |  | = |  | tcp-accept/enable-break

Executes a TCP server on the port indicated by port-no. When a connection is made by a client, conn is called with two values: an input port to receive from the client, and an output port to send to the client.

Each client connection is managed by a new custodian, and each call to conn occurs in a new thread (managed by the connection’s custodian). If the thread executing conn terminates for any reason (e.g., conn returns), the connection’s custodian is shut down. Consequently, conn need not close the ports provided to it. Breaks are enabled in the connection thread if breaks are enabled when run-server is called.

To facilitate capturing a continuation in one connection thread and invoking it in another, the parameterization of the run-server call is used for every call to handler. In this parameterization and for the connection’s thread, the current-custodian parameter is assigned to the connection’s custodian.

If conn-timeout is not #f, then it must be a non-negative number specifying the time in seconds that a connection thread is allowed to run before it is sent a break signal. Then, if the thread runs longer than (* conn-timeout 2) seconds, then the connection’s custodian is shut down. If conn-timeout is #f, a connection thread can run indefinitely.

If handler is provided, it is passed exceptions related to connections (i.e., exceptions not caught by conn-proc, or exceptions that occur when trying to accept a connection). The default handler ignores the exception and returns #<void>.

The run-server function uses listen, close, accept and accept/break in the same way as it might use tcp-listen, tcp-close, tcp-accept, and tcp-accept/enable-break to accept connections. Provide alternate procedures to use an alternate communication protocol (such as SSL) or to supply optional arguments in the use of tcp-listen. The listener? part of the contract indicates that the procedures must all work on the same kind of listener value.

The run-server procedure loops to serve client connections, so it never returns. If a break occurs, the loop will cleanly shut down the server, but it will not terminate active connections.

top← prev up next →