Strange JRC Race Condition

package com.mprew.be.service.x;

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;

import org.junit.Test;

/**
 * This is an interesting test case that seems to be indicating a JRE issue.
 *
 * This comes from http://stackoverflow.com/q/10982941/179850 and the poster named "Luke".
 *
 * I've boiled the code down to its lowest level and added some comments around the changes that can change the error
 * count. This is pretty repeatable to me with 4/5 runs generating errors. If you can't get it to fail I'd try
 * decreasing the fixed-rate period and increasing the NUMBER_TO_USE constant.
 */
public class StrangeRaceConditionTest {

    // if this is decreased it may remove the errors
    public static final int NUMBER_TO_USE = 1000000;

    private Map<Integer, Buffer> bufferMap = new HashMap<Integer, Buffer>();

    public static void main(String[] args) {
        new StrangeRaceConditionTest().strangeRaceConditionTest();
    }

    @Test
    public void strangeRaceConditionTest() {
        final Buffer buffer = getBuffer();

        TimerTask getBufferTask = new TimerTask() {
            @Override
            public void run() {
                buffer.getBuffer();
            }
        };
        // if the period is increased it seems to reduce the errors
        new Timer(true).scheduleAtFixedRate(getBufferTask, 0 /* delay ms */, 10 /* period ms */);

        for (long i = 0; i < NUMBER_TO_USE; i++) {
            // if we inline the remove() method here then no errors
            // if we change this to buffer.remove() then no errors
            remove();
        }

        assertEquals(0, buffer.getErrorC());
    }

    private synchronized void remove() {
        Buffer buffer = getBuffer();
        buffer.remove();
    }

    private synchronized Buffer getBuffer() {
        // if we remove this whole map nonesense then no errors
        Buffer buffer = bufferMap.get(1);
        // if this test/else is flipped so it is buffer == null ... then no errors
        if (buffer != null) {
            // if this line is commented out then no errors
            buffer = bufferMap.get(1);
        } else {
            buffer = new Buffer();
            bufferMap.put(1, buffer);
        }
        return buffer;
    }

    // moving this out to its own class file doesn't seem to help
    private static class Buffer {
        private List<Integer> list = new ArrayList<Integer>();
        private boolean insideGetBuffer = false;
        private int errorC = 0;

        public Buffer() {
            // initialize the list
            for (long i = 0; i < NUMBER_TO_USE; i++) {
                list.add(null);
            }
        }

        public synchronized void remove() {
            if (insideGetBuffer) {
                // adding a System.out.println here makes the problem more repeatable
                // System.out.println("How did we get here?");
                errorC++;
            }
        }

        public synchronized void getBuffer() {
            insideGetBuffer = true;
            try {
                // if you comment out this sleep then no errors
                Thread.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                insideGetBuffer = false;
            }
        }

        public synchronized int getErrorC() {
            return errorC;
        }
    }
}