How to demonstrate Java DCL problems?

Question

In Java Double checked locking (DCL) attempts to improve performance of lazy instantiation but without memory barriers is exposed to dangerous race conditions between the setting of a variable's address and the publishing of its value to main memory.

So my question is:

Can someone provide an example Java program/snippet, that reliably shows an incorrect value read as a result of DCL without volatile on the variable?

Here is my (failed ) attempt at it.

class Foo {
    String field = null; // not volatile
    String getField() {
        if( field == null )
        {
            synchronized (this) {
                if ( field == null )
                    field = new String("abc");
            }
        }
        return field;
    }
}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        if ( !Example.foo.getField().equals("abc") ) {
            System.out.println("Got an uninitialized FIELD !!!");
        }
    }
    
}
class Example {
    static Foo foo;
    public static void main(String[] args) throws InterruptedException {
        for( int i = 0; i < 1000000; ++i ) {
         foo = new Foo();
         Thread t1 = new Thread(new MyRunnable());
         Thread t2 = new Thread(new MyRunnable());
         t1.start();
         t2.start();
         t1.join();
         t2.join();
        }
    }
}

Obviously not being able to prove it doesn't mean that DCL is safe, but it would still be nice to have an obvious example that shows that it is dangerous.