On this page:
async-channel?
make-async-channel
async-channel-get
async-channel-try-get
async-channel-put
async-channel-put-evt
10.2.4 Buffered Asynchronous Channels

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

+See also Thread Mailboxes.

An asynchronous channel is like a channel, but it buffers values so that a send operation does not wait on a receive operation.

In addition to its use with procedures that are specific to asynchronous channels, an asynchronous channel can be used as a synchronizable event (see Events). An asynchronous channel is ready for synchronization when async-channel-get would not block; the asynchronous channel’s synchronization result is the same as the async-channel-get result.

procedure

(async-channel? v)  boolean?

  v : any/c
Returns #t if v is an asynchronous channel, #f otherwise.

procedure

(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).

procedure

(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.

procedure

(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.

procedure

(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.

procedure

(async-channel-put-evt ach v)  evt?

  ach : async-channel?
  v : any/c
Returns a synchronizable event that is ready for synchronization when (async-channel-put ach v) would return a value (i.e., when the channel holds fewer values already than its limit); the synchronization result of a asychronous channel-put event is the asychronous channel-put event itself.

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)