I can't imagine that this hasn't been asked before, so please direct
this post to an appropriate link if you know of it.

(send a f & args)
Dispatch an action to an agent. Returns the agent immediately.
Subsequently, in a thread from a thread pool, the state of the agent
will be set to the value of:

(send-off a f & args)
Dispatch a potentially blocking action to an agent. Returns the agent
immediately. Subsequently, in a separate thread, the state of the
agent will be set to the value of:

Why is there a distinction between an action and a blocking action?
What kind of concerns arise when you send a potentially blocking
action to an agent and why is send-off better accommodated to deal
with it?

>From scheduling I know that there are CPU-bound and IO-bound
processes. Perhaps send-off tends to hold off on yielding for longer
durations since it expects frequent interrupts. If this is the case, I
think it would be useful to elaborate on that in the documentation of
send-off, even if that's something implemented mostly in Java.

~ Kai
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to