• Type: Bug
    • Status: Closed
    • Priority: Major
    • Resolution: Fixed
    • Affects Version/s: 1.9, 2.0.0, 2.1, 2.2, 2.3, 2.3.1, 2.3.2
    • Fix Version/s: 2.4
    • Component/s: core/index
    • Labels:
    • Lucene Fields:


      Java's ThreadLocal is dangerous to use because it is able to take a
      surprisingly very long time to release references to the values you
      store in it. Even when a ThreadLocal instance itself is GC'd, hard
      references to the values you had stored in it are easily kept for
      quite some time later.

      While this is not technically a "memory leak", because eventually
      (when the underlying Map that stores the values cleans up its "stale"
      references) the hard reference will be cleared, and GC can proceed,
      its end behavior is not different from a memory leak in that under the
      right situation you can easily tie up far more memory than you'd
      expect, and then hit unexpected OOM error despite allocating an
      extremely large heap to your JVM.

      Lucene users have hit this many times. Here's the most recent thread:

      And here's another:

      And then there's LUCENE-436 and LUCENE-529 at least.

      A google search for "ThreadLocal leak" yields many compelling hits.

      Sun does this for performance reasons, but I think it's a terrible
      trap and we should work around it with Lucene.


        1. LUCENE-1383.patch
          7 kB
          Michael McCandless
        2. ScreenHunter_01 Sep. 13 08.40.jpg
          15 kB
          Chris Lu
        3. ScreenHunter_02 Sep. 13 08.42.jpg
          16 kB
          Chris Lu
        4. ScreenHunter_03 Sep. 13 08.43.jpg
          16 kB
          Chris Lu
        5. ScreenHunter_07 Sep. 13 19.13.jpg
          17 kB
          Chris Lu



            • Assignee:
              mikemccand Michael McCandless
              mikemccand Michael McCandless
            • Votes:
              0 Vote for this issue
              0 Start watching this issue


              • Created: