Taking a closer look at the code, Scott appears to be refreshing all his
SoftReferences after every allocation. That means the soft-references
will not be cleared right up until the moment an OutOfMemoryError would
be thrown if no more memory can be reclaimed. At that point the
finalisable objects are put on the finaliser queue, where they still
take memory up. No memory is available immediately and hence the JVM
goes OOME.

I have adapted his code to keep counters instead of counting. (Thinking
about it, switching to Reference.isEnqueued should work.) The byte[]
count is impossible, probably due to the (ancient, unclear) bug linked
below. My adaptation has various behaviours depending on parameters
values which determine whether or not there is enough time to run the
finalisers and recover.

http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4214755

Tom Hawtin

import java.lang.ref.*;
import java.util.concurrent.atomic.AtomicInteger;

public class SoftRef2 {
    final static int NUM_BLOCKS =
        Integer.getInteger("NUM_BLOCKS", 256);
    final static int BLOCK_SIZE =
        Integer.getInteger("BLOCK_SIZE", 1000000);
    final static int SLEEP_MILLIS =
        Integer.getInteger("SLEEP_MILLIS", 100);

    private final static class MemoryHog {
        private final byte[] arr;
        public MemoryHog(byte[] arr) {
            this.arr = arr;
        }
        public void finalize() {
            System.out.println("Finalizing " + this);
        }
    }
    private static class WeakArrayReference
    extends WeakReference<byte[]>
    {
        WeakArrayReference(
           byte[] referent, ReferenceQueue<? super byte[]> queue
        ) {
           super(referent, queue);
        }
    }

    public static void main(String[] args) throws Exception {
        System.out.println("NUM_BLOCKS: "+NUM_BLOCKS);
        System.out.println("BLOCK_SIZE: "+BLOCK_SIZE);
        System.out.println("SLEEP_MILLIS: "+SLEEP_MILLIS);

        final AtomicInteger arrayCount = new AtomicInteger();
        final AtomicInteger hogCount = new AtomicInteger();
        final ReferenceQueue<Object> queue =
            new ReferenceQueue<Object>();

        final Thread thread = new Thread(new Runnable() {
               public void run() {
                    try {
                        for (;;) {
                            Reference<?> reference = queue.remove();
                            if (
                                reference instanceof WeakArrayReference
                            ) {
                                arrayCount.decrementAndGet();
                            } else {
                                hogCount.decrementAndGet();
                            }
                        }
                    } catch (java.lang.InterruptedException exc) {
                        // Not expecting that.
                        exc.printStackTrace();
                    }
                }
        }, "Dead counter");
        thread.setDaemon(true);
        thread.setPriority(Thread.MAX_PRIORITY);
        thread.start();

        final java.util.List<Reference<?>> hogPen =
            new java.util.ArrayList<Reference<?>>(NUM_BLOCKS);
        for(int i=0; i<NUM_BLOCKS; ++i) {
            byte[] arr = new byte[BLOCK_SIZE];
            new WeakArrayReference(arr, queue);
            arrayCount.incrementAndGet();

            hogPen.add(new SoftReference<MemoryHog>(
                    new MemoryHog(arr), queue
            ));
            hogCount.incrementAndGet();

            System.out.println(
                "Allocated " + (i+1) + "; living: " +
                arrayCount.get() + " byte[], "+
                hogCount.get() + " head of hog."
            );

            if (SLEEP_MILLIS != 0) {
                Thread.sleep(SLEEP_MILLIS);
            }
        }
    }
}