►Reference: Racket
►10 Concurrency and Parallelism
▼10.2 Synchronization
On this page:
async-channel?
make-async-channel
async-channel-get
async-channel-try-get
async-channel-put
async-channel-put-evt
  top← prev  up  next → 
10.2.4 Buffered Asynchronous Channels

 (require racket/async-channel)
The bindings documented in this section are provided by the racket/async-channel library, not racket/base or racket.

+See also Thread Mailboxes.

(async-channel? v) → boolean?
  v : any/c
Returns #t if v is an asynchronous channel, #f otherwise.

(make-async-channel [limit]) → async-channel?
  limit : (or/c exact-positive-integer? #f) = #f
Returns an asynchronous channel with a buffer limit of limit items. A get operation blocks when the channel is empty, and a put operation blocks when the channel has limit items already. If limit is #f, the channel buffer has no limit (so a put never blocks).

The asynchronous channel value can be used directly with sync. The channel blocks until async-channel-get would return a value, and the unblock result is the received value.

(async-channel-get ach) → any/c
  ach : async-channel?
Blocks until at least one value is available in ach, and then returns the first of the values that were put into async-channel.

(async-channel-try-get ach) → any/c
  ach : async-channel?
If at least one value is immediately available in ach, returns the first of the values that were put into ach. If async-channel is empty, the result is #f.

(async-channel-put ach v) → void?
  ach : async-channel?
  v : any/c
Puts v into ach, blocking if ach’s buffer is full until space is available.

(async-channel-put-evt ach v) → evt?
  ach : channel?
  v : any/c
Returns a synchronizable event that is blocked while (async-channel-put ach v) would block. The unblock result is the event itself. See also sync.

Examples:

  (define (server input-channel output-channel)
    (thread (lambda ()
              (define (get)
                (async-channel-get input-channel))
              (define (put x)
                (async-channel-put output-channel x))
              (define (do-large-computation)
                (sqrt 9))
              (let loop ([data (get)])
                (case data
                  [(quit) (void)]
                  [(add) (begin
                           (put (+ 1 (get)))
                           (loop (get)))]
                  [(long) (begin
                            (put (do-large-computation))
                            (loop (get)))])))))
  (define to-server (make-async-channel))
  (define from-server (make-async-channel))
  > (server to-server from-server)

  #<thread>

  > (async-channel? to-server)

  #t

  > (printf "Adding 1 to 4\n")

  Adding 1 to 4

  > (async-channel-put to-server 'add)
  > (async-channel-put to-server 4)
  > (printf "Result is ~a\n" (async-channel-get from-server))

  Result is 5

  > (printf "Ask server to do a long computation\n")

  Ask server to do a long computation

  > (async-channel-put to-server 'long)
  > (printf "I can do other stuff\n")

  I can do other stuff

  > (printf "Ok, computation from server is ~a\n"
            (async-channel-get from-server))

  Ok, computation from server is 3

  > (async-channel-put to-server 'quit)

  top← prev  up  next →