A question on synchronized with example

[Brian Tkatch]

A first example in Schildt's Java: A Beginner's Guide displays what synchronized does (and a little of what it doesn't, too.) He then says to remove the word synchronized to see what happens. I typed in the example (with minor changes):

class SumArray
{
 private int sum;

 /*synchronized*/ int sumArray(int num[])
 {
  sum = 0;

  for(int i = 0; i < num.length; i++)
  {
   sum += num[i];
   System.out.println("Running total for " + Thread.currentThread().getName() + " is " + sum);   
   try{Thread.sleep(10);} catch(InterruptedException exc){System.out.println("Thread interrupted.");}
  }
  return sum;  
 }
}

class MyThread
 implements Runnable
{
 Thread thrd;
 static SumArray sa = new SumArray();
 int a[];
 int answer;

 MyThread(String name, int num[])
 {
  thrd = new Thread(this, name);
  a = num;
  thrd.start();
 }

 public void run()
 {
  int sum;

  System.out.println(thrd.getName() + " starting.");

  answer = sa.sumArray(a);
  System.out.println("Sum for " + thrd.getName() + " is " + answer);

  System.out.println(thrd.getName() + " terminating.");
 }
}

class Sync
{
 public static void main(String arg[])
 {
  int a[] = {1, 2, 3, 4, 5};

  MyThread mt1 = new MyThread("Child #1", a);
  MyThread mt2 = new MyThread("Child #2", a);

  try
  {
   mt1.thrd.join();
   mt2.thrd.join();
  }
  catch(InterruptedException exc){System.out.println("Main thread interrupted.");}
 }
}

With synchronized:

Child #2 starting.
Child #1 starting.
Running total for Child #2 is 1
Running total for Child #2 is 3
Running total for Child #2 is 6
Running total for Child #2 is 10
Running total for Child #2 is 15
Running total for Child #1 is 1
Sum for Child #2 is 15
Child #2 terminating.
Running total for Child #1 is 3
Running total for Child #1 is 6
Running total for Child #1 is 10
Running total for Child #1 is 15
Sum for Child #1 is 15
Child #1 terminating.

Without synchronized:

Child #1 starting.
Child #2 starting.
Running total for Child #1 is 1
Running total for Child #2 is 1
Running total for Child #1 is 3
Running total for Child #2 is 5
Running total for Child #1 is 8
Running total for Child #2 is 11
Running total for Child #1 is 15
Running total for Child #2 is 19
Running total for Child #1 is 24
Running total for Child #2 is 29
Sum for Child #1 is 29
Child #1 terminating.
Sum for Child #2 is 29
Child #2 terminating.

Each thread adds to 15 separately, but without synchronized they only add to 29. Why?

Also, how can the second thread start first? I've seen that a few times already, both in this example and the previous one (not shown in this post.)

[Tony Docherty]

The reason the total is 29 for the unsynchronized method in the example you have shown is as follows:

There is only 1 instance of the SumArray class and so there is only one 'sum' variable which is incremented by both threads when calling the sumArray method.
Child#1 calls sumArray and executes the first line of the method which sets sum to zero. It then executes the first iteration of the for loop which adds the first element of the num array (1) to sum and prints out its value (1). Finally it sleeps.
Child#2 calls sumArray and executes the first line of the method which sets sum to zero. It then executes the first iteration of the for loop which adds the first element of the num array (1) to sum and prints out its value (1). Finally it sleeps.
The for loop continues adding all the remaining elements of the num array (2, 3, 4, 5 = 14) until both threads complete. ie you add 14 and 14 to 1 which = 29.

To answer your other question when you call start on a thread there is no guarantee of when it's run method will actually get called so the order of execution of multiple threads may and probably will change. For example if you start 10 threads you will see the order of execution can change with each run.

[Brian Tkatch]

Now i'm embarrased; i missed something obvious. It's being set and then reset. Doh! I guess it's possible (is it?) that the second thread will also set it to zero earlier and hit 30, or less and hit less.

I understand that threads are given different time slices. But shouldn't the first one start first?

[Henry Wong]

Brian Tkatch wrote:
I understand that threads are given different time slices. But shouldn't the first one start first?

The specification doesn't require how threads are started, nor how are they time sliced. This is to allow the underlying OS to schedule threads as needed.

Henry