►The Racket Reference
►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 : async-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 →