多线程比单线程快吗？

Question

我想看看多线程是否比单线程快，所以我在这里做一个演示：

public class ThreadSpeedTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("cpu number:"
                + Runtime.getRuntime().availableProcessors());
        singleThreadStart();
//      secondThreadStart();
//      fiveThreadStart();
    }

    private static void sum() {
        long sum = 0;
        for (int i = 0; i < 1000000; i++) {
            sum += i;
        }
        System.out.println(sum);
    }

    private static void singleThreadStart() {
        new Thread(new Runnable() {

            public void run() {
                long start = System.nanoTime();
    //          sum();
    //          sum();
    //          sum();
                sum();
                sum();
                long end = System.nanoTime();
                System.out.println("cost time:" + (end - start));
            }
        }).start();
    }

    private static void secondThreadStart() {
        long start = System.nanoTime();
        Thread thread1 = new Thread(new Runnable() {

            public void run() {
                sum();
            }
        });
        thread1.start();
        Thread thread2 = new Thread(new Runnable() {

            public void run() {
                sum();
            }
        });
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long end = System.nanoTime();
        System.out.println("cost time:" + (end - start));
    }

    private static void fiveThreadStart() {
        long start = System.nanoTime();
        Thread thread1 = new Thread(new Runnable() {

            public void run() {
                sum();
            }
        });
        thread1.start();
        Thread thread2 = new Thread(new Runnable() {

            public void run() {
                sum();
            }
        });
        thread2.start();
        Thread thread3 = new Thread(new Runnable() {

            public void run() {
                sum();
            }
        });
        thread3.start();
        Thread thread4 = new Thread(new Runnable() {

            public void run() {
                sum();
            }
        });
        thread4.start();
        Thread thread5 = new Thread(new Runnable() {

            public void run() {
                sum();
            }
        });
        thread5.start();

        try {
            thread1.join();
            thread2.join();
            thread3.join();
            thread4.join();
            thread5.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long end = System.nanoTime();
        System.out.println("cost time:" + (end - start));
    }
}

首先我运行singleThread开始用两个sum方法，结果是

cpu number:4
499999500000
499999500000
cost time:6719000

然后我运行secondThreadStart,结果是

cpu number:4
499999500000
499999500000
cost time:14299000

然后我运行singleThread开始用5个sum方法，结果是

cpu number:4
499999500000
499999500000
499999500000
499999500000
499999500000
cost time:10416000

最后我运行五个ThreadStart，结果是

cpu number:4
499999500000
499999500000
499999500000
499999500000
499999500000
cost time:15708000

我的问题是：

SecondThreadStart比singleThreadStart耗时多，是因为创建线程的开销吗？
cpu 数字是 4，尽管创建线程的成本很高，那么使用超过 4 个线程会比使用四个线程慢吗？
如果我想做一些需要更多时间的事情，最好使用四个线程吗？

Answer 1

创建额外的线程绝对是有成本的。在启动新线程之前，您应该需要做大量的工作。
我假设这意味着您有一个四核 CPU。最佳线程数实际上取决于工作负载，如果线程出于某种原因正在等待，它们可能能够上下文切换到另一个线程，并且您可能会看到线程数大于物理内核数的好处。
我不明白这个问题。

Answer 2

1.SecondThreadStart cost more time than singleThreadStart, is it because the cost of creating thread?

创建线程当然有开销。

2.The cpu number is 4, despite the cost of creating thread, so using thread number more than 4 will slower than using four threads?

如果线程完成得非常快（不受 IO 限制和 CPU 限制），即使线程数超过 CPU 核心数，您也可以获得良好的结果。

3.If I want to do something cost much time, using four threads to do is best?

您可以使用高级 java 并发类（newWorkStealingPool of Executors）

参考这个SE问题：

Java's Fork/Join vs ExecutorService - when to use which?

总的来说：

多线程可以通过使用更多 CPU 能力来提高应用程序的吞吐量。

这取决于很多因素。

线程数
CPU 核心
线程创建成本和上下文切换（可能对多线程有效）
数据结构
数据的可变性（可能不利于多线程）
数据结构的共享访问/并发（可能适用于多线程）
应用程序类型：CPU 绑定或 IO 绑定

如果您的应用程序

，多线程将提供出色的结果

Less CPU bound, less IO Bound（但对于这些应用程序仍然可以使用多线程）
无共享数据

如果不是，性能取决于上述因素，单线程应用程序和多线程应用程序之间的吞吐量会有所不同。

一些很好的 SE 问题：

https://softwareengineering.stackexchange.com/questions/97615/what-can-multiple-threads-do-that-a-single-thread-cannot

Does multithreading always yield better performance than single threading?

Why single thread is faster than multithreading in Java?

好文章：

thetechsolo.wordpress.com篇文章

java-performance篇文章

多线程比单线程快吗？

Is multithreading faster than single thread?

java

multithreading

processor