public class _02_visibility implements Runnable {
    /** Переменная, чье изменение ожидает увидеть другой поток. */
    private int val;
//    private volatile int val;

    /** {@inheritDoc} */
    @Override public void run() {
        // Инкремент переменной в цикле до тех пор, пока поток не заметит изменение переменной.
        int i = 0;

        while (val == 0)
            i++;

        System.out.println("Value change observed: " + i);
    }

    /**
     * Точка входа.
     */
    public static void main(String[] args) throws Exception {
        _02_visibility test = new _02_visibility();

        // Запуск потока.
        new Thread(test).start();

        // Даем время для старта второго потока.
        Thread.sleep(100);

        // После этого изменения второй поток должен остановиться.
        test.val = 1;

        System.out.println("Value changed.");
    }
}

import sun.misc.*;

import java.lang.reflect.*;
import java.security.*;

public class Test {
    /**
     * Main method.
     *
     * @param args Arguments, none required.
     * @throws Exception Failure.
     */
    public static void main(String[] args) throws Exception {
        final ValueHolder holder = new PlainValueHolder();

        new Thread(new Runnable() {
            @Override 
            public void run() {
                int i = 0;

                while (holder.get() == 0)
                    i++;

                System.out.println("Value change observed: " + holder.get());
            }
        }).start();

        Thread.sleep(100);

        holder.set(1);

        System.out.println("Value changed.");
    }

    /**
     * Value holder.
     */
    private static interface ValueHolder {
        /**
         * Get value.
         *
         * @return Value.
         */
        public int get();

        /**
         * Set value.
         *
         * @param val Value.
         */
        public void set(int val);
    }

    /**
     * Value holder with regular field access.
     */
    private static class PlainValueHolder implements ValueHolder {
        /** Value. */
        private int val;

        /** {@inheritDoc} */
        @Override 
        public int get() {
            return val;
        }

        /** {@inheritDoc} */
        @Override 
        public void set(int val) {
            this.val = val;
        }
    }

    /**
     * Value holder with volatile field access.
     */
    private static class VolatileValueHolder implements ValueHolder {
        /** Value. */
        private volatile int val;

        /** {@inheritDoc} */
        @Override 
        public int get() {
            return val;
        }

        /** {@inheritDoc} */
        @Override 
        public void set(int val) {
            this.val = val;
        }
    }

    /**
     * Value holder with regular field access through unsafe.
     */
    private static class PlainUnsafeValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override 
        public int get() {
            return unsafe().getInt(this, offset);
        }

        /** {@inheritDoc} */
        @Override 
        public void set(int val) {
            unsafe().putInt(this, offset, val);
        }
    }

    /**
     * Value holder with volatile field read through unsafe and regular field write.
     */
    private static class ReadVolatileValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override 
        public int get() {
            return unsafe().getIntVolatile(this, offset);
        }

        /** {@inheritDoc} */
        @Override 
        public void set(int val) {
            this.val = val;
        }
    }

    /**
     * Value holder with regular field read and volatile field write through unsafe.
     */
    private static class WriteVolatileValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override 
        public int get() {
            return val;
        }

        /** {@inheritDoc} */
        @Override 
        public void set(int val) {
            unsafe().putIntVolatile(this, offset, val);
        }
    }

    /**
     * Value holder with regular field read and ordered field write through unsafe.
     */
    private static class WriteOrderedValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override 
        public int get() {
            return val;
        }

        /** {@inheritDoc} */
        @Override 
        public void set(int val) {
            unsafe().putOrderedInt(this, offset, val);
        }
    }

    /**
     * Value holder with regular field read guarded with monitor enter and regular field write.
     */
    private static class MonitorEnterValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override 
        public int get() {
            unsafe().monitorEnter(this);

            return val;
        }

        /** {@inheritDoc} */
        @Override 
        public void set(int val) {
            this.val = val;
        }
    }

    /**
     * Base class for value holders using unsafe.
     */
    private abstract static class UnsafeValueHolder implements ValueHolder {
        /** Unsafe. */
        protected final Unsafe unsafe;

        /** Field offset. */
        protected final long offset;

        /** Value. */
        protected int val;

        /**
         * Constructor.
         */
        protected UnsafeValueHolder() {
            try {
                unsafe = unsafe();

                offset = unsafe.objectFieldOffset(UnsafeValueHolder.class.getDeclaredField("val"));
            }
            catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        /**
         * Get instance of Unsafe.
         *
         * @return Instance of Unsafe.
         */
        protected Unsafe unsafe() {
            try {
                return Unsafe.getUnsafe();
            }
            catch (SecurityException ignored) {
                try {
                    return AccessController.doPrivileged
                        (new PrivilegedExceptionAction<Unsafe>() {
                            @Override
                            public Unsafe run() throws Exception {
                                Field f = Unsafe.class.getDeclaredField("theUnsafe");

                                f.setAccessible(true);

                                return (Unsafe) f.get(null);
                            }
                        });
                }
                catch (PrivilegedActionException e) {
                    throw new RuntimeException("Failed to get Unsafe.", e.getCause());
                }
            }
        }
    }
}

import sun.misc.*;

import java.lang.reflect.*;
import java.security.*;
import java.util.concurrent.*;

public class Test {
    /** Expected cache size. */
    private static final int CACHE_SIZE = 10 * 1024 * 1024;

    /** Expected cache line size. */
    private static final int CACHE_LINE_SIZE = 64;

    /** Amount of secondary threads. */
    private static final int THREAD_COUNT = Runtime.getRuntime().availableProcessors() * 2;

    /** Monitor. */
    private static final Object mux = new Object();

    /**
     * Main method.
     *
     * @param args Arguments, none required.
     * @throws Exception Failure.
     */
    public static void main(String[] args) throws Exception {
        final ValueHolder holder = new PlainValueHolder();

        final CacheLine[] cache = new CacheLine[CACHE_SIZE / CACHE_LINE_SIZE];

        for (int i = 0; i < CACHE_SIZE / CACHE_LINE_SIZE; i++)
            cache[i] = new CacheLine();

        new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;

                while (holder.get() == 0)
                    i++;

                System.out.println("Value change observed: " + i);
            }
        }).start();

        Thread.sleep(100);

        final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT);

        Thread[] threads = new Thread[THREAD_COUNT];

        for (int i = 0; i < THREAD_COUNT; i++) {
            final int idx = i + 1;

            Thread thread = new Thread(new Runnable() {
                @Override 
                public void run() {
                    synchronized (mux) {
                        holder.set(idx);
                    }

                    System.out.println("Value changed from another thread: " + idx);

                    try {
                        barrier.await();
                    }
                    catch (Exception ignore) {

                    }

                    for (CacheLine cacheLine : cache)
                        cacheLine.change();
                }
            });

            thread.start();

            threads[i] = thread;
        }

        for (Thread thread : threads)
            thread.join();

        // Iterate over all cache lines to prevent optimizations.
        long sum = 0;

        for (CacheLine line : cache)
            sum += line.sum();

        System.out.println("Iterated over cache content: " + sum);
    }

    /**
     * Cache line abstraction.
     */
    private static class CacheLine {
        /** Array. */
        private final long[] arr = new long[CACHE_LINE_SIZE / 8];

        /** Next index to change. */
        private int nextIdx;

        /**
         * Change some value in cache line.
         */
        public void change() {
            synchronized (mux) {
                for (int i = 0; i < 100 * arr.length; i++)
                    arr[nextIdx++ % arr.length]++;
            }
        }

        /**
         * Calculate cache line sum.
         *
         * @return Cache line sum.
         */
        public long sum() {
            long sum = 0;

            for (long item : arr)
                sum += item;

            return sum;
        }
    }

    /**
     * Value holder.
     */
    private static interface ValueHolder {
        /**
         * Get value.
         *
         * @return Value.
         */
        public int get();

        /**
         * Set value.
         *
         * @param val Value.
         */
        public void set(int val);
    }

    /**
     * Value holder with regular field access.
     */
    private static class PlainValueHolder implements ValueHolder {
        /** Value. */
        private int val;

        /** {@inheritDoc} */
        @Override
        public int get() {
            return val;
        }

        /** {@inheritDoc} */
        @Override
        public void set(int val) {
            this.val = val;
        }
    }

    /**
     * Value holder with volatile field access.
     */
    private static class VolatileValueHolder implements ValueHolder {
        /** Value. */
        private volatile int val;

        /** {@inheritDoc} */
        @Override
        public int get() {
            return val;
        }

        /** {@inheritDoc} */
        @Override
        public void set(int val) {
            this.val = val;
        }
    }

    /**
     * Value holder with regular field access through unsafe.
     */
    private static class PlainUnsafeValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override
        public int get() {
            return unsafe.getInt(this, offset);
        }

        /** {@inheritDoc} */
        @Override
        public void set(int val) {
            unsafe.putInt(this, offset, val);
        }
    }

    /**
     * Value holder with volatile field read through unsafe and regular field write.
     */
    private static class ReadVolatileValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override
        public int get() {
            return unsafe.getIntVolatile(this, offset);
        }

        /** {@inheritDoc} */
        @Override
        public void set(int val) {
            this.val = val;
        }
    }

    /**
     * Value holder with regular field read and volatile field write through unsafe.
     */
    private static class WriteVolatileValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override
        public int get() {
            return val;
        }

        /** {@inheritDoc} */
        @Override
        public void set(int val) {
            unsafe.putIntVolatile(this, offset, val);
        }
    }

    /**
     * Value holder with regular field read and ordered field write through unsafe.
     */
    private static class WriteOrderedValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override
        public int get() {
            return val;
        }

        /** {@inheritDoc} */
        @Override
        public void set(int val) {
            unsafe.putOrderedInt(this, offset, val);
        }
    }

    /**
     * Value holder with regular field read guarded with monitor enter and regular field write.
     */
    private static class MonitorEnterValueHolder extends UnsafeValueHolder {
        /** {@inheritDoc} */
        @Override
        public int get() {
            unsafe.monitorEnter(this);

            return val;
        }

        /** {@inheritDoc} */
        @Override
        public void set(int val) {
            this.val = val;
        }
    }

    /**
     * Base class for value holders using unsafe.
     */
    private abstract static class UnsafeValueHolder implements ValueHolder {
        /** Unsafe. */
        protected final Unsafe unsafe;

        /** Field offset. */
        protected final long offset;

        /** Value. */
        protected int val;

        /**
         * Constructor.
         */
        protected UnsafeValueHolder() {
            try {
                unsafe = unsafe();

                offset = unsafe.objectFieldOffset(UnsafeValueHolder.class.getDeclaredField("val"));
            }
            catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        /**
         * Get instance of Unsafe.
         *
         * @return Instance of Unsafe.
         */
        private Unsafe unsafe() {
            try {
                return Unsafe.getUnsafe();
            }
            catch (SecurityException ignored) {
                try {
                    return AccessController.doPrivileged
                        (new PrivilegedExceptionAction<Unsafe>() {
                            @Override
                            public Unsafe run() throws Exception {
                                Field f = Unsafe.class.getDeclaredField("theUnsafe");

                                f.setAccessible(true);

                                return (Unsafe) f.get(null);
                            }
                        });
                }
                catch (PrivilegedActionException e) {
                    throw new RuntimeException("Failed to get Unsafe.", e.getCause());
                }
            }
        }
    }
}