Uploaded image for project: 'Clojure'
  1. CLJ-124

GC Issue 120: Determine mechanism for controlling automatic shutdown of Agents, with a default policy and mechanism for changing that policy as needed


    • Type: Improvement
    • Status: Open
    • Priority: Minor
    • Resolution: Unresolved
    • Affects versions: Release 1.6, Release 1.5
    • Fix versions: None
    • Labels:
    • Approval:
    • Patch:


      The original description when this ticket was vetted is below, starting with "Reported by cemer...@snowtide.com, June 01, 2009". This prefix attempts to summarize the issue and discussion.


      Several Clojure functions involving agents and futures, such as future, pmap, clojure.java.shell/sh, and a few others, create non-daemon threads in the JVM in an ExecutorService called soloExecutor created via Executors#newCachedThreadPool. The javadocs for this method here http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html#newCachedThreadPool%28%29 say "Threads that have not been used for sixty seconds are terminated and removed from the cache." This causes a 60-second wait after a Clojure program is done before the JVM process exits. Questions about this confusing behavior come up a couple of times per year on the Clojure Google group. Search for "shutdown-agents" to find most of these occurrences, since calling (shutdown-agents) at the end of one's program typically eliminates this 60-second wait.


      % java -cp clojure.jar clojure.main -e "(println 1)"
      [ this case exits quickly ]
      % java -cp clojure.jar clojure.main -e "(println @(future 1))"
      [ 60-second pause before process exits, at least on many platforms and JVMs ]

      Summary of comments before July 2014:

      Most of the comments on this ticket on or before August 23, 2010 were likely spread out in time before being imported from the older ticket tracking system into JIRA. Most of them refer to an older suggested patch that is not in JIRA, and compilation problems it had with JDK 1.5, which is no longer supported by Clojure 1.6.0. I think these comments can be safely ignored now.

      Alex Miller blogged about this and related issues here: http://tech.puredanger.com/2010/06/08/clojure-agent-thread-pools/

      Since then, two of the suggestions Alex raised have been addressed. One by CLJ-378 Closed and one by the addition of set-agent-send-executor! and similar functions to Clojure 1.5.0: https://github.com/clojure/clojure/blob/master/changes.md#23-clojurecoreset-agent-send-executor-set-agent-send-off-executor-and-send-via

      One remaining issue is the topic of this ticket, which is how best to avoid this 60-second pause.

      Approach #1: automatically shut down agents

      One method is mentioned in Chas Emerick's original description below, suggested by Rich Hickey, but perhaps long enough ago he may no longer endorse it: Create a Var *auto-shutdown-agents* that when true (the default value), clojure.lang.Agent shutdown() is called after the clojure.main entry point. This removes the surprising wait for common methods of starting Clojure, while allowing expert users to change that value to false if desired.

      Approach #2: create daemon threads by default

      Another method mentioned by several people in the comments is to change the threads created in agent thread pools to daemon threads by default, and perhaps to deprecate shutdown-agents or modify it to be less dangerous. That approach is discussed a bit more in Alex's blog post linked above, and in a comment from Alexander Taggart on July 11, 2011 below.

      Approach #3:

      The only other comment before 2014 that is not elaborated in this summary is shoover's suggestion: There are already well-defined and intuitive ways to block on agents and futures. Why not deprecate shutdown-agents and force users to call await and deref if they really want to block? In the pmap situation one would have to evaluate the pmap form.

      Approach #4: Create a cached thread pool with a timeout much lower than 60 seconds

      This could be done by using one of the ThreadPoolExecutor constructors with a keepAliveTime parameter of the desired time.

      Patch: clj-124-v1.patch clj-124-daemonthreads-v1.patch

      At most one of these patches should be considered, depending upon the desired approach to take.

      Patch clj-124-v1.patch implements appproach #1 using *auto-shutdown-agents*. See the Jul 31 2014 comment when this patch was added for some additional details.

      Patch clj-124-daemonthreads-v1.patch implements approach #2 and is straightforward.

       Reported by cemer...@snowtide.com, Jun 01, 2009
      There has been intermittent chatter over the past months from a couple of
      people on the group (e.g.
      and in #clojure about some clojure scripts hanging, either for a constant
      time (usually reported as a minute or so with no CPU util) or seemingly
      forever (or until someone kills the process).
      I just hit a similar situation in our compilation process, which invokes
      clojure.lang.Compile from ant.  The build process for this particular
      project had taken 15 second or so, but after adding a couple of pmap calls,
      that build time jumped to ~1:15, with roughly zero CPU utilization over the
      course of that last minute.
      Adding a call to Agent.shutdown() in the finally block in
      clojure.lang.Compile/main resolved the problem; a patch including this
      change is attached.  I wouldn't suspect anyone would have any issues with
      such a change.
      In general, it doesn't seem like everyone should keep tripping over this
      problem in different directions.  It's a very difficult thing to debug if
      you're not attuned to how clojure's concurrency primitives work under the
      hood, and I would bet that newer users would be particularly affected.
      After discussion in #clojure, rhickey suggested adding a
      *auto-shutdown-agents* var, which:
      - if true when exiting one of the main entry points (clojure.main, or the
      legacy script/repl entry points), Agent.shutdown() would be called,
      allowing for the clean exit of the application
      - would be bound by default to true
      - could be easily set to false for anyone with an advanced use-case that
      requires agents to remain active after the main thread of the application
      This would obviously not help anyone initializing clojure from a different
      entry point, but this may represent the best compromise between
      least-surprise and maximal functionality for advanced users.
      In addition to the above, it perhaps might be worthwhile to change the
      keepalive values used to create the Threadpools used by c.l.Actor's
      Executors.  Currently, Actor uses a default thread pool executor, which
      results in a 60s keepalive.  Lowering this to something much smaller (1s?
      5s?) would additionally minimize the impact of Agent's threadpools on Java
      applications that embed clojure directly (and would therefore not benefit
      from *auto-shutdown-agents* as currently conceived, leading to puzzling
      'hanging' behaviour).  I'm not in a position to determine what impact this
      would have on performance due to thread churn, but it would at least
      minimize what would be perceived as undesirable behaviour by users that are
      less familiar with the implementation details of Agent and code that
      depends on it.
      Comment 1  by cemer...@snowtide.com, Jun 01, 2009
      Just FYI, I'd be happy to provide patches for either of the suggestions mentioned




            • Assignee:
              alexmiller Alex Miller
              cemerick Chas Emerick
            • Votes:
              7 Vote for this issue
              7 Start watching this issue


              • Created: