FULL PRODUCT VERSION :
java version "1.6.0-beta2"
Java(TM) SE Runtime Environment (build 1.6.0-beta2-b86)
Java HotSpot(TM) Server VM (build 1.6.0-beta2-b86, mixed mode)

ADDITIONAL OS VERSION INFORMATION :
Microsoft Windows XP [Version 5.1.2600]

A DESCRIPTION OF THE PROBLEM :
We have a request/reply scenario with 2 different threads. Thread 1 performs a request via Thread 2 and wait on a semaphore. Thread 2 sets a reply in the request and notifies the semaphore. The set/getReply in the Request class is either synchronized or the Reply field is volatile (see test source). With both versions we have situations where the semaphore is was notified but getReply returns null in thread 1.

It seems the instructions of thread 2 (setReply, notify semaphore) have been reordered in (notify, setReply) or the memory changes of thread 2 have not been flushed when thread 1 calls getReply.

Everything works fine with JDK1.5.0_07.


REGRESSION.  Last worked in version mustang

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
Use the attached testdriver as follows:

JMMTest 100000

It runs 30, 60, 100 pairs of request/reply threads with either volatile or synchronized Request class. It fails often but you might be required to run it multiple times. Of course, use a multiprocessor machine.

EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
You should see this kind of output which indicates a getReply() == null:

D:\jdk1.6.0\bin\java -Xmx1024M -cp ;../testdriver JMMTest 100000
-- Type: 1
---- 30 Pairs ...
-- Type: 2
---- 30 Pairs ...
Reply == null, n=75717, class=JMMTest$SRequest
ACTUAL -
D:\jdk1.6.0\bin\java -Xmx1024M -cp ;../testdriver JMMTest 100000
-- Type: 1
---- 30 Pairs ...
-- Type: 2
---- 30 Pairs ...
Reply == null, n=75717, class=JMMTest$SRequest

REPRODUCIBILITY :
This bug can be reproduced often.

---------- BEGIN SOURCE ----------
public class JMMTest
{
  public JMMTest(int n)
  {
    int[] pairs = new int[]{30, 60, 100};

    for (int i = 0; i < pairs.length; i++)
    {
      for (int k = 1; k < 3; k++)
      {
        System.out.println("-- Type: " + k);
        System.out.println("---- " + pairs[i] + " Pairs ...");
        Replier[] replier = new Replier[pairs[i]];
        Requestor[] requestor = new Requestor[pairs[i]];
        for (int j = 0; j < pairs[i]; j++)
        {
          replier[j] = new Replier(n);
          requestor[j] = new Requestor(new RequestFactory(k), replier[j], n);
        }
        for (int j = 0; j < pairs[i]; j++)
        {
          replier[j].start();
          requestor[j].start();
        }
        for (int j = 0; j < pairs[i]; j++)
        {
          try
          {
            replier[j].join();
            requestor[j].join();
          } catch (InterruptedException e)
          {
            e.printStackTrace();
          }
        }
      }
    }

  }
  public static void main(String args[])
  {
    new JMMTest(Integer.parseInt(args[0]));
  }

  private class Requestor extends Thread
  {
    RequestFactory factory = null;
    Replier replier = null;
    int n = 0;

    public Requestor(RequestFactory factory, Replier replier, int n)
    {
      this.factory = factory;
      this.replier = replier;
      this.n = n;
    }

    public void run()
    {
      for (int i = 0; i < n; i++)
      {
        Request request = factory.createRequest();
        replier.setRequest(request);
        replier.getSemaphore().notifySingleWaiter();
        request.getSemaphore().waitHere();
        synchronized (replier)
        {
          if (request.getReply() == null)
          {
            System.err.println("Reply == null, n=" + request.getN() + ", class=" + request.getClass().getName());
            System.exit(-1);
          }
        }
      }
    }
  }

  private class Replier extends Thread
  {
    Request request = null;
    Semaphore semaphore = new Semaphore();
    int n = 0;

    public Replier(int n)
    {
      this.n = n;
    }

    public Semaphore getSemaphore()
    {
      return semaphore;
    }

    public synchronized void setRequest(Request request)
    {
      this.request = request;
    }

    public void run()
    {
      for (int i = 0; i < n; i++)
      {
        semaphore.waitHere();
        synchronized (this)
        {
          if (request == null)
          {
            System.err.println("request == null, n=" + n);
            System.exit(-1);
          }
          semaphore.reset();
          Semaphore sem = request.getSemaphore();
          request.setReply(new Reply(request.getN()));
          request = null;
          sem.notifySingleWaiter();
        }
      }
    }
  }


  private class Semaphore
  {
    boolean notified = false;

    public Semaphore()
    {
    }

    public synchronized void waitHere()
    {
      if (!notified)
      {
        try
        {
          wait();
        } catch (Exception ignored)
        {
        }
      }
    }

    public synchronized void waitHere(long ms)
    {
      if (!notified)
      {
        try
        {
          wait(ms);
        } catch (Exception ignored)
        {
        }
      }
    }

    public synchronized void notifySingleWaiter()
    {
      notified = true;
      notify();
    }

    public synchronized void reset()
    {
      notified = false;
    }
  }

  private class RequestFactory
  {
    int type = 0;
    int n = 0;

    public RequestFactory(int type)
    {
      this.type = type;
    }

    public Request createRequest()
    {
      Request r = null;
      switch (type)
      {
        case 0:
          r = new URequest(++n);
          break;
        case 1:
          r = new VRequest(++n);
          break;
        case 2:
          r = new SRequest(++n);
          break;
      }
      return r;
    }

  }

  private interface Request
  {
    public int getN();

    public Reply getReply();

    public void setReply(Reply reply);

    public Semaphore getSemaphore();
  }

  private class URequest implements Request
  {
    int n = 0;
    Reply reply = null;
    Semaphore semaphore = new Semaphore();

    public URequest(int n)
    {
      this.n = n;
    }

    public int getN()
    {
      return n;
    }

    public Reply getReply()
    {
      return reply;
    }

    public void setReply(Reply reply)
    {
      this.reply = reply;
    }

    public Semaphore getSemaphore()
    {
      return semaphore;
    }
  }

  private class VRequest implements Request
  {
    int n = 0;
    volatile Reply reply = null;
    Semaphore semaphore = new Semaphore();

    public VRequest(int n)
    {
      this.n = n;
    }

    public int getN()
    {
      return n;
    }

    public Reply getReply()
    {
      return reply;
    }

    public void setReply(Reply reply)
    {
      this.reply = reply;
    }

    public Semaphore getSemaphore()
    {
      return semaphore;
    }
  }

  private class SRequest implements Request
  {
    int n = 0;
    Reply reply = null;
    Semaphore semaphore = new Semaphore();

    public SRequest(int n)
    {
      this.n = n;
    }

    public int getN()
    {
      return n;
    }

    public synchronized Reply getReply()
    {
      return reply;
    }

    public synchronized void setReply(Reply reply)
    {
      this.reply = reply;
    }

    public Semaphore getSemaphore()
    {
      return semaphore;
    }
  }

  private class Reply
  {
    int n = 0;
    boolean ok = false;
    Exception exception = null;
    boolean timeout = false;
    int requestNumber = 0;
    transient byte[] b = new byte[1024];

    public Reply(int n)
    {
      this.n = n;
    }
  }
}

---------- END SOURCE ----------

CUSTOMER SUBMITTED WORKAROUND :
None. Nothing works to avoid that.

Release Regression From : 5.0u7
The above release value was the last known release where this 
bug was not reproducible. Since then there has been a regression.