java - 并发/多线程何时有助于提高性能？

Question

在得知并发确实增加了许多人的吞吐量后，我一直计划在项目中使用并发。 现在我在多线程或并发方面还没有做太多工作，因此决定在实际项目中使用它之前学习并进行简单的概念验证。
以下是我尝试过的两个示例:

1. With use of concurrency

    public static void main(String[] args) 

    {
        System.out.println("start main ");

        ExecutorService es = Executors.newFixedThreadPool(3);
        long startTime = new Date().getTime();
        Collection<SomeComputation> collection = new ArrayList<SomeComputation>();
        for(int i=0; i< 10000; i++){
            collection.add(new SomeComputation("SomeComputation"+i));
        }
        try {
            List<Future< Boolean >> list = es.invokeAll(collection);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("\n end main "+(new Date().getTime() - startTime));
    }

2. Without use of concurrency

        public static void main(String[] args) {

          System.out.println("start main ");
          long startTime = new Date().getTime();
          Collection<SomeComputation> collection = new ArrayList<SomeComputation>();
          for(int i=0; i< 10000; i++){
          collection.add(new SomeComputation("SomeComputation"+i));
        }
        for(SomeComputation sc:collection)
        {
        sc.compute();
        }
        System.out.println("\n end main "+(new Date().getTime() - startTime));
        }

    Both share a common class

        class SomeComputation implements Callable<Boolean>
        {
            String name;
            SomeComputation(String name){this.name=name;}
            public Boolean compute()
            {
                someDumbStuff();
                return true;
            }

            public Boolean call()
            {
                someDumbStuff();
                return true;
            }

            private void someDumbStuff()
            {
                for (int i = 0;i<50000;i++)
                {
                    Integer.compare(i,i+1);
                }
                System.out.print("\n done with "+this.name);
            }
        }

现在对每种方法进行 20 次奇数运行后的分析。
第一个并发平均需要 451 毫秒。
没有并发的第二个平均需要 290 毫秒。
现在我了解到这取决于配置、操作系统、版本(java 7)和处理器。 但这两种方法都是相同的。 还了解到，当计算量很大时，并发成本是可以承受的。但这一点我不清楚。
希望有人能帮助我更多地理解这一点。
PS:我尝试寻找类似的问题，但可以找到此类问题。如果您这样做，请评论链接。

Answer 1

并发性至少有两个不同的目的:1) 性能，2) 代码简单性(例如 1000 个 Web 请求监听器)。

如果您的目的是性能，那么您无法获得比您投入工作的硬件核心数量更多的加速。 (这仅适用于线程受 CPU 限制的情况。) 更重要的是，每个线程都有很大的启动开销。 因此，如果您在 4 核计算机上启动 1000 个线程，您不可能比 4 倍加速更好，但与此相反，您有 1000 个线程启动成本。