Java 6 Mac OS X Lion上奇怪的并发行为

Question

I've been experimenting with difference between intrinsic locks and java.util.concurrent.ReentrantLock for some time now. I've found very strange thing. Consider following code:

public class WriteOnceRunAnywhere {

    private static long counter = 0;

    public static void main(String[] args) throws InterruptedException {

        final int numThreads = 2;
        final int numIterations = Integer.MAX_VALUE;

        Runnable inc = new Runnable() {
            public void run() {
                for (int i = 0; i < numIterations; i++) {

                    increment();

                    if (i % 10000000 == 0)
                        System.out.println(Thread.currentThread().getName());
                }
            }
        };

        for (int i = 0; i < numThreads; i++)
            new Thread(inc).start();
    }

    public static synchronized void increment() {
        counter++;
    }
}

Simple thing, no fancy stuff. Right? Happens to break! Most likely when you run it, it won't end. After some ping-pong between threads you'll see only one thread is actually running. The other hangs forever:

Thread-1 Thread-2 Thread-1 Thread-2 Thread-1 ... Thread-2 Thread-2 Thread-2 Thread-2 Thread-2 Thread-2 Thread-2 Thread-2 Thread-2 ...

After that, java process can't accept jvisualvm connection. CPU load drops and continuously stays at about 1.0%.

Mac OS X Lion 10.7.2 (11C74), 2.53 GHz Intel Core i5

java version "1.6.0_29" Java(TM) SE Runtime Environment (build 1.6.0_29-b11-402-11M3527) Java HotSpot(TM) 64-Bit Server VM (build 20.4-b02-402, mixed mode)

Can someone tell me what the heck is happening here?

UPD Looks like the bug will be fixed in 1.6.30 see

Answer 1

Looks like you are observing an existing bug in Mac OS 7 JDK 1.6. You can see the same issue occurred here:

http://cs.oswego.edu/pipermail/concurrency-interest/2012-January/008778.html

You may want to read from the start at

http://cs.oswego.edu/pipermail/concurrency-interest/2012-January/008759.html

Finally there seems to be a resolution in for Open JDK 7.

http://cs.oswego.edu/pipermail/concurrency-interest/2012-January/008789.html

Long story short. It will only fail with JDK 1.6_14 (or greater < JDK 7) and Max OS 7. Their test and the results you are seeing are very similar.

I am guessing you can't even get a jstack or load jconsole?

Answer 2

Try turning off -XX:-UseBiasedLocking It probably ping-pongs until the code is optimised (try -XX:+PrintCompilation and then it effectively determines the program will run faster if only one thread holds the lock. eg the synchronized is effectively moved outside the loop.

You will see this behaviour often when you using multiple threads to do something which is faster to do single threaded.

---

You can either have each thread alternatively increment the value or you can have one loop run until it stops (at Integer.MAX_VALUE) and then the second one.

public class CountingWithThreads {
    static long count1 = 0;
    static long count2 = 0;

    public static void main(String... args) throws InterruptedException {
        long start1 = System.nanoTime();
        Thread t1a = new Thread(new CountsSingleThreaded(Integer.MAX_VALUE));
        Thread t1b = new Thread(new CountsSingleThreaded(Integer.MAX_VALUE));
        t1a.start();
        t1b.start();
        t1a.join();
        t1b.join();
        long time1 = System.nanoTime() - start1;
        System.out.printf("Single threaded, took %.1f second to count to %,d%n", time1 / 1e9, count1);

        long start2 = System.nanoTime();
        Thread t2a = new Thread(new CountsAlternatively(true, 1000000));
        Thread t2b = new Thread(new CountsAlternatively(false, 1000000));
        t2a.start();
        t2b.start();
        t2a.join();
        t2b.join();
        long time2 = System.nanoTime() - start2;
        System.out.printf("Alternating multi-threaded took %.1f second to count to %,d%n", time2 / 1e9, count2);

    }

    static class CountsSingleThreaded implements Runnable {
        private final long maxValue;

        CountsSingleThreaded(long maxValue) {
            this.maxValue = maxValue;
        }

        public void run() {
            synchronized (CountingWithThreads.class) {
                for (long i = 0; i < maxValue; i++) {
                    count1++;
                }
            }
        }
    }

    static class CountsAlternatively implements Runnable {
        private final boolean even;
        private final long maximum;

        CountsAlternatively(boolean even, long maximum) {
            this.even = even;
            this.maximum = maximum;
        }

        public void run() {
            try {
                synchronized (CountingWithThreads.class) {
                    while (count2 < maximum)
                        if (((count2 & 1) == 0) == even) {
                            count2++;
                            CountingWithThreads.class.notify();
                        } else {
                            CountingWithThreads.class.wait();
                        }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

prints

Single threaded, took 2.3 second to count to 4,294,967,294
Alternating multi-threaded took 3.4 second to count to 1,000,000

Running one thread to completion one at a time is the most efficient. If you force strict alternating of the counters (the most extreme example of mult-threading) it is over 1000x slower.

Answer 3

We have a developer preview that (among other things) fixes some low level synchronization problems. If you've had problems with synchronization on Mac JDK6, please test this preview with your code and see if it fixes the problem on your hardware. Thanks.

The developer preview is live: https://developer.apple.com/downloads/index.action?name=Java%20for%20Mac%20OS%20X%20Developer%20Preview .