False Sharing && Java 7

最新推荐文章于 2025-08-11 14:43:21 发布

weixin_33966095

最新推荐文章于 2025-08-11 14:43:21 发布

阅读量55

点赞数

CC 4.0 BY-SA版权

文章标签： java 数据库

原文链接：https://yq.aliyun.com/articles/26409

本文探讨了Java 7版本中虚假共享的问题，并通过实验代码展示了如何使用填充字段来避免这一现象，旨在提升并发编程环境下的性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原文：http://mechanical-sympathy.blogspot.hk/2011/08/false-sharing-java-7.html （因为被墙移动到墙内）

In my previous post on False Sharing I suggested it can be avoided by padding the cache line with unused longfields. It seems Java 7 got clever and eliminated or re-ordered the unused fields, thus re-introducing false sharing. I’ve experimented with a number of techniques on different platforms and found the following code to be the most reliable.

 
import java.util.concurrent.atomic.AtomicLong; 

     02 

public final class FalseSharing 

    implements Runnable 

     05{

    public final static int NUM_THREADS = 4; // change 

    public final static long ITERATIONS = 500L * 1000L * 1000L; 

    private final int arrayIndex; 

     09 

    private static PaddedAtomicLong[] longs = new PaddedAtomicLong[NUM_THREADS]; 

    static 

    { 

        for (int i = 0; i < longs.length; i++) 

        { 

            longs[i] = new PaddedAtomicLong(); 

        } 

    } 

     18 

    public FalseSharing(final int arrayIndex) 

    { 

        this.arrayIndex = arrayIndex; 

    } 

     23 

    public static void main(final String[] args) throws Exception 

    { 

        final long start = System.nanoTime(); 

        runTest(); 

        System.out.println("duration = " + (System.nanoTime() - start)); 

    } 

     30 

    private static void runTest() throws InterruptedException 

    { 

        Thread[] threads = new Thread[NUM_THREADS]; 

     34 

        for (int i = 0; i < threads.length; i++) 

        { 

            threads[i] = new Thread(new FalseSharing(i)); 

        } 

     39 

        for (Thread t : threads) 

        { 

            t.start(); 

        } 

     44 

        for (Thread t : threads) 

        { 

            t.join(); 

        } 

    } 

     50 

    public void run() 

    { 

        long i = ITERATIONS + 1; 

        while (0 != --i) 

        { 

            longs[arrayIndex].set(i); 

        } 

    } 

     59 

    public static long sumPaddingToPreventOptimisation(final int index) 

    { 

        PaddedAtomicLong v = longs[index]; 

        return v.p1 + v.p2 + v.p3 + v.p4 + v.p5 + v.p6; 

    } 

     65 

    public static class PaddedAtomicLong extends AtomicLong 

    { 

        public volatile long p1, p2, p3, p4, p5, p6 = 7L; 

    } 

     70}

With this code I get similar performance results to those stated in the previous False Sharing article. The padding inPaddedAtomicLong above can be commented out to see the false sharing effect.

I think we should all lobby the powers that be inside Oracle to have intrinsics added to the language so we can have cache line aligned and padded atomic classes. This and some other low-level changes would help make Java a real concurrent programming language. We keep hearing them say multi-core is coming. I say it is here and Java needs to catch up.