false sharing 研究

public final class FalseSharing implements Runnable {
	public static int NUM_THREADS = 4; // change
	public final static long ITERATIONS = 500L * 1000L * 1000L;
	private final int arrayIndex;
	private static VolatileLong[] longs;

	public FalseSharing(final int arrayIndex) {
		this.arrayIndex = arrayIndex;
	}

	public static void main(final String[] args) throws Exception {
		Thread.sleep(10000);
		System.out.println("starting....");
		if (args.length == 1) {
			NUM_THREADS = Integer.parseInt(args[0]);
		}

		longs = new VolatileLong[NUM_THREADS];
		for (int i = 0; i < longs.length; i++) {
			longs[i] = new VolatileLong();
		}
		final long start = System.nanoTime();
		runTest();
		System.out.println("duration = " + (System.nanoTime() - start));
	}

	private static void runTest() throws InterruptedException {
		Thread[] threads = new Thread[NUM_THREADS];
		for (int i = 0; i < threads.length; i++) {
			threads[i] = new Thread(new FalseSharing(i));
		}
		for (Thread t : threads) {
			t.start();
		}
		for (Thread t : threads) {
			t.join();
		}
	}

	public void run() {
		long i = ITERATIONS + 1;
		while (0 != --i) {
			longs[arrayIndex].value = i;
		}
	}

	public final static class VolatileLong {
		public volatile long value = 0L;
//		public long p1, p2, p3, p4, p5, p6; //
//
//				public long sum() {
//					return p1 + p2 + p3 + p4 + p5 + p6;
//				}
	}
}

public final class NoFalseSharing implements Runnable {
	public static int NUM_THREADS = 4; // change
	public final static long ITERATIONS = 500L * 1000L * 1000L;
	private final int arrayIndex;
	private static VolatileLong[] longs;

	public NoFalseSharing(final int arrayIndex) {
		this.arrayIndex = arrayIndex;
	}

	public static void main(final String[] args) throws Exception {
		Thread.sleep(10000);
		System.out.println("starting....");
		if (args.length == 1) {
			NUM_THREADS = Integer.parseInt(args[0]);
		}

		longs = new VolatileLong[NUM_THREADS];
		for (int i = 0; i < longs.length; i++) {
			longs[i] = new VolatileLong();
		}
		final long start = System.nanoTime();
		runTest();
		System.out.println("duration = " + (System.nanoTime() - start));
	}

	private static void runTest() throws InterruptedException {
		Thread[] threads = new Thread[NUM_THREADS];
		for (int i = 0; i < threads.length; i++) {
			threads[i] = new Thread(new NoFalseSharing(i));
		}
		for (Thread t : threads) {
			t.start();
		}
		for (Thread t : threads) {
			t.join();
		}
	}

	public void run() {
		long i = ITERATIONS + 1;
		while (0 != --i) {
			longs[arrayIndex].value = i;
		}
	}

	public final static class VolatileLong {
		public volatile long value = 0L;
		public long p1, p2, p3, p4, p5, p6;
		public long sum() {
			return p1 + p2 + p3 + p4 + p5 + p6;
		}
	}
}

import java.lang.reflect.Field;
import java.security.AccessController;
import java.security.PrivilegedExceptionAction;

import sun.misc.Unsafe;

public final class SuperNoFalseSharing implements Runnable {
	public static int NUM_THREADS = 4; // change
	public final static long ITERATIONS = 500L * 1000L * 1000L;
	private final int arrayIndex;
	private static VolatileLong[] longs;

	public SuperNoFalseSharing(final int arrayIndex) {
		this.arrayIndex = arrayIndex;
	}

	public static void main(final String[] args) throws Exception {
		Thread.sleep(10000);
		System.out.println("starting....");
		if (args.length == 1) {
			NUM_THREADS = Integer.parseInt(args[0]);
		}

		longs = new VolatileLong[NUM_THREADS];
		for (int i = 0; i < longs.length; i++) {
			longs[i] = new VolatileLong();
		}
		final long start = System.nanoTime();
		runTest();
		System.out.println("duration = " + (System.nanoTime() - start));
	}

	private static void runTest() throws InterruptedException {
		Thread[] threads = new Thread[NUM_THREADS];
		for (int i = 0; i < threads.length; i++) {
			threads[i] = new Thread(new SuperNoFalseSharing(i));
		}
		for (Thread t : threads) {
			t.start();
		}
		for (Thread t : threads) {
			t.join();
		}
	}

	public void run() {
		long i = ITERATIONS + 1;
		while (0 != --i) {
			longs[arrayIndex].set(i);
		}
	}

	public final static class VolatileLong {

		static final long INITIAL_VALUE = -1L;
	    private static final Unsafe UNSAFE;
	    private static final long VALUE_OFFSET;

	    static
	    {
	        UNSAFE = getUnsafe();
	        final int base = UNSAFE.arrayBaseOffset(long[].class);
	        final int scale = UNSAFE.arrayIndexScale(long[].class);
	        VALUE_OFFSET = base + (scale * 7);
	    }

	    private final long[] paddedValue = new long[15];

	    /**
	     * Create a sequence initialised to -1.
	     */
	    public VolatileLong()
	    {
	        this(INITIAL_VALUE);
	    }

	    private static Unsafe getUnsafe() {

	    	final Unsafe THE_UNSAFE;

	        {
	            try
	            {
	                final PrivilegedExceptionAction<Unsafe> action = new PrivilegedExceptionAction<Unsafe>()
	                {
	                    public Unsafe run() throws Exception
	                    {
	                        Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
	                        theUnsafe.setAccessible(true);
	                        return (Unsafe) theUnsafe.get(null);
	                    }
	                };

	                THE_UNSAFE = AccessController.doPrivileged(action);
	            }
	            catch (Exception e)
	            {
	                throw new RuntimeException("Unable to load unsafe", e);
	            }
	        }
			return THE_UNSAFE;

		}

		/**
	     * Create a sequence with a specified initial value.
	     *
	     * @param initialValue The initial value for this sequence.
	     */
	    public VolatileLong(final long initialValue)
	    {
	        UNSAFE.putOrderedLong(paddedValue, VALUE_OFFSET, initialValue);
	    }

	    /**
	     * Perform a volatile read of this sequence's value.
	     *
	     * @return The current value of the sequence.
	     */
	    public long get()
	    {
	        return UNSAFE.getLongVolatile(paddedValue, VALUE_OFFSET);
	    }

	    /**
	     * Perform an ordered write of this sequence.  The intent is
	     * a Store/Store barrier between this write and any previous
	     * store.
	     *
	     * @param value The new value for the sequence.
	     */
	    public void set(final long value)
	    {
	        UNSAFE.putOrderedLong(paddedValue, VALUE_OFFSET, value);
	    }

	    /**
	     * Performs a volatile write of this sequence.  The intent is
	     * a Store/Store barrier between this write and any previous
	     * write and a Store/Load barrier between this write and any
	     * subsequent volatile read.
	     *
	     * @param value The new value for the sequence.
	     */
	    public void setVolatile(final long value)
	    {
	        UNSAFE.putLongVolatile(paddedValue, VALUE_OFFSET, value);
	    }

	    /**
	     * Perform a compare and set operation on the sequence.
	     *
	     * @param expectedValue The expected current value.
	     * @param newValue The value to update to.
	     * @return true if the operation succeeds, false otherwise.
	     */
	    public boolean compareAndSet(final long expectedValue, final long newValue)
	    {
	        return UNSAFE.compareAndSwapLong(paddedValue, VALUE_OFFSET, expectedValue, newValue);
	    }

	    /**
	     * Atomically increment the sequence by one.
	     *
	     * @return The value after the increment
	     */
	    public long incrementAndGet() {
	        return addAndGet(1L);
	    }

	    /**
	     * Atomically add the supplied value.
	     *
	     * @param increment The value to add to the sequence.
	     * @return The value after the increment.
	     */
	    public long addAndGet(final long increment) {
	        long currentValue;
	        long newValue;

	        do
	        {
	            currentValue = get();
	            newValue = currentValue + increment;
	        }
	        while (!compareAndSet(currentValue, newValue));

	        return newValue;
	    }

	    public String toString() {
	        return Long.toString(get());
	    }
	}
}