Is multithreading faster than single thread?

Question

I want to check whether multithreading is faster than single thread,then I make a demo here:

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));
    }
}

First I run singleThreadStart with two sum method,the result is

cpu number:4
499999500000
499999500000
cost time:6719000

Then I run secondThreadStart,the result is

cpu number:4
499999500000
499999500000
cost time:14299000

Then I run singleThreadStart with five sum method,the result is

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

Finally I run fiveThreadStart,the result is

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

My questions are:

SecondThreadStart cost more time than singleThreadStart, is it because the cost of creating thread?
The cpu number is 4, despite the cost of creating thread, so would using more than 4 thread be slower than using four threads?
If I want to do something that takes much more time, is using four threads to do is best?

There is an overhead to using theads, **and** you should also see [Amdahl's law](https://en.wikipedia.org/wiki/Amdahl's_law). — Elliott Frisch, Apr 18 '16 at 03:08
3.If I want to do something cost much time, using four threads to do is best? - please elaborate — Anand Vaidya, Apr 18 '16 at 04:07

score 5 · Accepted Answer · edited May 23 '17 at 12:17

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

Certainly there is overhead with creation of 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?

If the threads are finishing very quickly ( Not IO bound and CPU bound), you can have good results even if number of threads are more than number of CPU cores.

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

You can use advanced java concurrent classes ( newWorkStealingPool of Executors)

Refer to this SE question:

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

In General:

Multi threading may improve throughput of the application by using more CPU power.

it depends on a lot of factors.

Number of threads
CPU cores
Thread creation cost and context switching ( may work against multi-threading)
Data structures
Mutability of data ( may work against multi-threading)
Shared access/ Concurrency of data structure ( may work against multi-threading)
Type of application : CPU bound or IO Bound

Multi threading will provide excellent results if your application is

Less CPU bound, less IO Bound ( But still multi-threading can be used for these applications)
No shared data

If not, the performance depends on above factors and throughput will vary between single threaded application and multi-threading application.

Some good SE questions:

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?

Good articles:

thetechsolo.wordpress.com article

java-performance article

Just wanted to challenge 'not IO bound' part here. In many cases, multithreading gives excellent results for I/O bound application, because you can do multiple things in parallel, rather than blocking your entire app waiting for single I/O operation. This is also most common case when using more threads than cpu cores is beneficial. In some cases you can work around it in single-threaded applications (select-like behaviour), but in java, a lot of APIs are blocking (JDBC for example). — Artur Biesiadowski, Apr 18 '16 at 09:56
I want to highlight the fact that IO bound application performance is dependent on disk IO — Ravindra babu, Apr 18 '16 at 10:17

score 4 · Answer 2 · answered Apr 18 '16 at 03:18

There is absolutely a cost to creating additional threads. You should have a non-trivial amount of work needed before spinning up a new thread.
I assume this means you have a quad-core CPU. The optimal number of threads actually depends on the workload, if threads are waiting for whatever reason they may be able to context switch to a another thread and you may see a benefit with a number of threads greater than the number of physical cores.
I don't understand the question.

3. once you have all the CPU busy, adding more threads is likely to increase overhead for a CPU bound task. +1 — Peter Lawrey, Apr 18 '16 at 06:45

Is multithreading faster than single thread?

2 Answers2

Linked