CODEWITHSUNDEEP
javamultithreadingparallel-processingcalculator
Brooke
Brooke

Reputation: 119

Adding numbers using multiple threads in java

I am having trouble figuring out what my code is doing as this is my first time coding using multiple threads. To start off, in attempt to learn this type of programming I decided to write a miniature program that uses 8 threads to sum a number. However, no matter what I do it seems as if my program never stops when count = 10, it continues onward. I am using 8 threads as I planned on expanding my program to do large calculations. However, these threads are not correlating at all. They are going way past 10. I have used a synchronized method. I have tried a lock. I have tried implementing both at the same time. No matter what, it appears as if the threads still calculate past 10. See below for my current code.

public class calculator implements Runnable {

static int counter = 0;
static int sum = 0;

private synchronized static int getAndIncrement()
{
//  System.out.println("counter is  : " + counter);

    int temp = counter;
    counter = counter + 1;
    System.out.println("counter is now : " + counter);
    return temp;
}

private synchronized void addToSum(int value)
{
//  System.out.println("sum : " + sum + " value: " + value);
    sum += value;
}

@Override
public void run() 
{
    // TODO Auto-generated method stub
    while(counter < 10)
    {
        int tempVal = getAndIncrement();
        System.out.println("temp val : " + tempVal);
        addToSum(tempVal);
    //  System.out.println("sum is now : " + sum);

    }

}


}

This is my main method:

    public static void main(String[] args)
{


    calculator[] calc = new calculator[8];
    Thread[] thread = new Thread[8];

    final long startTime = System.currentTimeMillis();

    for(int i = 0; i < 8; i++)
    {
        calc[i] = new calculator();
        thread[i] = new Thread(calc[i]);
        thread[i].start();
    }

    while(thread[0].isAlive() ||thread[1].isAlive() || thread[2].isAlive() || thread[3].isAlive() || thread[4].isAlive() || thread[5].isAlive() || thread[6].isAlive() || thread[7].isAlive())
    {}

    final long endTime = System.currentTimeMillis();
    System.out.println(calculator.sum);
    System.out.println("Execution time : " + (startTime - endTime));
}

I appreciate the help!

Upvotes: 1

Views: 3901

Answers (2)

alain6985
alain6985

Reputation: 16

I've just tested your sample and found the addToSum method doesn't work as expected here with heavy multi-thread, even if keyword is present.

Here, as sum variable is , the method can be made too.

After adding the keyword, the behavior is as expected:

    private static synchronized void addToSum(int value)
    {
        sum += value;
    }

Here a simple test (addToSum replaced by incSum for simplicity) :

    class IncrementorThread implements Runnable {
        private static int sum = 0;
        private static synchronized void incSum()
        {
            sum ++;
        }
        public void run() {
            incSum();
            Thread.yield();
        }
    }

    void testIncrementorThread1() {
        ExecutorService executorService = Executors.newCachedThreadPool();
        //ExecutorService executorService = Executors.newSingleThreadExecutor() // result always ok without needing concurrency precaution
        for(int i = 0; i < 5000; i++)
            executorService.execute(new IncrementorThread());
        executorService.shutdown();
        executorService.awaitTermination(4000, TimeUnit.MILLISECONDS);
        System.out.println("res = "+IncrementorThread.sum); // must be 5000
    }

Result must be 5000, which is not the case if we remove the keyword from the method incSum()

Upvotes: 0

Caius Brindescu
Caius Brindescu

Reputation: 607

The synchronized keyword takes the object lock. This means that two methods that are synchronized cannot execute on the same object. They will, however, execute concurrently on invocation on 2 different objects.

In your example, your code had 8 objects of calculator. The synchronized methods do not help you. Each thread uses it's separate object. You can completely remove the synchronized keyword, and your code will be semantically equivalent.

To avoid this, use the atomic version of the objects (AtomicInt) or lock on the objects themselves: synchronized(counter){...} but for this to work you will have to change the type to Integer.

Upvotes: 1

Related Questions