Java multi-threading programme not using a lot of CPU

Question

I am beginner in programming and Java, and this is my first multi-core program. The problem is that my program never uses more than 13% of my CPU. I do not know if I do it in the right way or not.

How do I compute faster and use more CPU resources?

My program consists of three class:

1. The "main class that instantiates the Work object with a number of threads

2. A "T1" class that extends Thread and contains the work to be performed

3. A "Work" class that launches the desired thread numbers and displays the time taken by all threads to perform the work

Here is the code of my Main class:

public static void main(String[] args) {

  System.out.println("Number of CPUs available = " + Runtime.getRuntime().availableProcessors()); //Display the number of CPUs available
  int iteration = 100000000; // Define a number of itterations to do by all threads

  /*
  Instantiates each work with a different number of threads (1, 4, 8, 12, and 24)
  */
    Work  t1 = new Work(1);
    Work  t4 = new Work(4);
    Work  t8 = new Work(8);
    Work t12 = new Work(12);
    Work t24 = new Work(24);


   /*
    Launch the work for each thread with the specified number of iterations
    */
    t1.goWork(iteration);
    t4.goWork(iteration);
    t8.goWork(iteration);
    t12.goWork(iteration);
    t24.goWork(iteration);

    }

And here the Work class code:

public class Work {

    static long time;     // A variable that each thread increase by the time it takes to complete its task.
    static int itterationPerThread;      // A variable that stores the number of itterations Per Thread to do.
    static int finish;     // A variable that each thread incrase when it finish its task, used to wait until all thread has complete their task.
    private int numberOfThreads;     // The number of threads to launch.
    /**
     *
     * The constructor, set the number Of threads to run
     * @param numberOfThreads
     */
    public Work(int numberOfThreads)
    {
        this.numberOfThreads = numberOfThreads;   //Set the number of threads
    }

    /**
     *
     * A method that launch a specified number of thread in the constructor of the class, and distributes the a number of iteration of each thread.
     * The method does nothing until each thread completes its task and print the time needed for all threads to complete their tasks.
     * @param itterationPerThread
     */
    public void goWork(int itterationPerThread)
    {
        finish = 0;   //Reset the variable in the case that we call the method more than one time
        time = 0;    //Reset the variable in the case that we call the method more than one time
        this.itterationPerThread = itterationPerThread/numberOfThreads;   // Divide the given number of iterations by the number of threads specified in the constructor

        for (int i=0; i<numberOfThreads; i++)   //Launch the specified number of threads
        {
              new T1().run();
        }

        while (finish != numberOfThreads)    //Do nothing until all thread as completed their task
        {
        }
        System.out.println("Time for " + numberOfThreads + " thread = " + time + " ms");   //Display the total time
    }

}

And finally my T1 class:

public class T1 extends Thread{

    @Override
    public void run()
    {
        long before = System.currentTimeMillis();

        for (int i=0; i<Work.itterationPerThread; i++) //Get the thread busy with a number of itterations
        {
            Math.cos(2.1545); //Do something...
        }

         long after = System.currentTimeMillis(); //Compute the elapsed time
         Work.time += after - before; //Increase the static variable in Work.java by the time elapsed for this thread
         Work.finish++; // Increase the static variable in Work.java when the thread has finished its job
    }
}

The programme gives me the following ouput on my machine (four physical cores and eight hyperthreaded):

Number of CPUs available = 8

Time for 1 thread = 11150 ms

Time for 4 thread = 4630 ms

Time for 8 thread = 2530 ms

Time for 12 thread = 2530 ms

Time for 24 thread = 2540 ms

According to my CPU this result seems correct, but my CPU usage never exceeds 13%.

I found the following Stack Overflow post, but I did not really find an answer to my question.

Answer 1

Thank you all for answering my question:

Yes, the JVM does not calculate the Math.cos(2.1545); on each iteration, so as said I've tried with Math.cos(i); on the original programme and there is a big difference!

And for the multi Thread, as said, I've created a custom implementation of the interface Runnable, instead of extending Thread and now use the Start(); method instead of run();

I now use the join method to wait until thread finish and remove the static variable. Now the program use the full CPU load with the correct number of threads.

Just for information, here is my new code for the work class:

public class Work {

    private Thread[] threadArray; //An array to store a specified number of new threads in the constructor
    /**
     *
     * The constructor, set to the number Of threads to run
     * @param numberOfThreads
     */
    public Work(int numberOfThreads)
    {

        threadArray = new Thread[numberOfThreads];
    }

    /**
     *
     * A methode that launch a specified number of threads in the constructor of the class, and distributes the a number of iteration of each thread.
     * the methode wait until each thread complete their task and print the time needed for all thread to complette their task.
     * @param itterationForAllThread   --> the total of itteration to do by all thread
     */
    public void goWork(int itterationForAllThread)
    {
        long time = 0; // A variable used to compute the elapsed time
        int itterationPerThread; // A variable that store the number of itterations Per Thread to do
        itterationPerThread = itterationForAllThread/threadArray.length; //Divide the given number of itteration by the number of tread specified in the constructor

        for(int i=0; i<threadArray.length; i++) //Launch the specified number of threads
        {
              threadArray[i] = new Thread(new T1(itterationPerThread));  //Create a new thread
              threadArray[i].start();  //Start the job
        }

        long before = System.currentTimeMillis();

        for (Thread thread : threadArray) //For each thread wait until it finish
        {
            try {
                 thread.join(); //Wait for the thread as finish
            }
            catch (InterruptedException ex)
            {
                ex.printStackTrace();
            }
        }
        long after = System.currentTimeMillis();
        time = after - before; //Compute the time elapsed

        System.out.println("Time for " + threadArray.length + " Thread = " + time + " ms"); //Display the total time for the number of threads
    }
}

And here the T1 class:

public class T1 implements Runnable{

    private int iterrattionPerThread;

    T1(int iterrattionPerThread)
    {
        this.iterrattionPerThread=iterrattionPerThread;
    }


    @Override
    public void run()
    {
        for(int i=0; i<iterrattionPerThread; i++) //Get the thread busy with a number of iterations
        {
            Math.cos(i); //Do something that the JVM can not cache and need to be recaculated every iteration
        }
    }
}

Answer 2

Instead of calling Thread.run(), which implements what your thread does, you should call Thread.start(), which will create a new thread and call run() on that new thread.

Now you are running run() on your main thread, without making a new thread. Since you have 13% CPU load, I expect you have 8 cores (meaning you have fully filled a single core).

Even better would be to create a custom implementation of the interface Runnable, instead of extending Thread. You can then run it on a thread as follows:

Thread t = new Thread(new MyRunnableTask());
t.start();

This is the common way because it gives you the flexibility (later on) to use more advanced mechanisms, such as ExecutorService.

EDIT: As also noted in some of the comments. You are also changing the same variables (the static ones in Work) from several threads. You should never do this, because it allows for race conditions. For instance incrementing a variable can cause one, as explained here.