Hello,

I made a simple test (see below) to verify my assumption that a variable mutated sequentially by multiple threads must be marked as volatile to have mutations visible across these threads. How comes my test succeeds even though I omitted the volatile keyword?

Thanks,
Sébastien

import java.util.concurrent.*;

public class VolatileTest {

    static class CountTask implements Runnable {
        public int count = 0;             // volatile omitted
        public void run() { count++; }
        <at> Override
        public String toString() {return String.valueOf(count);}
    };

    static class SimpleExecutor implements Runnable {

       LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
      
       public void submit(Runnable runnable) { queue.offer(runnable); }

       volatile Thread thread = null;

       public void run() {

          thread = Thread.currentThread();
         
          while (thread != null) {

            try {
                Runnable task = queue.take();
                task.run();
            } catch (InterruptedException e) {}
          }
       }
   
       public void shutdown() {
         Thread t = thread;
         thread = null;
         t.interrupt();
       }
      
       public SimpleExecutor() {
           new Thread(this).start();
       }
    }
   
    static class LoopTask implements Runnable {
        CountDownLatch latch;
        int count;
        Runnable task;
        SimpleExecutor[] executors;

        /** Repeat a task sequentially using different executors
         *
         * <at> param executors the executors
         * <at> param count     the number of iterations
         * <at> param latch     latch decremented after the last iteration
         * <at> param task      the task invoked repeatedly
         */
        public LoopTask(SimpleExecutor[] executors, int count, CountDownLatch latch, Runnable task) {
            this.executors = executors;
            this.latch = latch;
            this.count = count;
            this.task  = task;
        }

        public void run() {
            if (count == 0)
                latch.countDown();
            else {
                task.run();
                executors[count % executors.length].submit(new LoopTask(executors, count - 1, latch, task));
            }
        }
    }

     public static void main(String[] args) throws Exception {
       int loops = 1000000;
       int nbExecs = 10;
      
       CountDownLatch latch = new CountDownLatch(1);
       SimpleExecutor[] executors = new SimpleExecutor[nbExecs];
      
       for (int i = 0; i < executors.length; i++)
         executors[i] = new SimpleExecutor();
      
       CountTask task = new CountTask();
      
       try {
           new LoopTask(executors, loops, latch, task).run();

           latch.await();

           System.out.println(task);
           assert(task.count == loops); 
       } finally {
           for (int i = 0; i < executors.length; i++)
               executors[i].shutdown();
       }
     }
}

2011/1/7 Mark Thornton <mthornton <at> optrak.co.uk>

2011/1/7 Holger Hoffstätte <holger.hoffstaette <at> googlemail.com>

2011/1/7 Holger Hoffstätte <holger.hoffstaette <at> googlemail.com>

On 07.01.2011 16:01, Sébastien Bocq wrote:
> I made a simple test (see below) to verify my assumption that a variable
> mutated sequentially by multiple threads must be marked as volatile to
> have mutations visible across these threads. How comes my test succeeds
> even though I omitted the volatile keyword?

http://en.wikipedia.org/wiki/Memory_ordering
In short: you got lucky.

What worries me is that I get lucky each time I run the test which means I can't rely on regression tests for catching these kinds of mistakes, at least on my current test setup (Intel Core Duo, Windows and Oracle JDK 1.6). I'd feel better if I could get my hands on a test platform less tolerant towards these kinds bugs. Any advice?

Thanks,
Sébastien

It's really the handoff using the blocking queue that is providing memory barrier. And the way you wrote, you have essentially a serial execution (using multiple threads).