If the append() method synchronizes on the StringBuffer object (which
I believe it does) there would be some gains if it's faster to check a
lock you already have than to acquire and release it, and the Hotspot
compiler doesn't eliminate the lock/unlock code completely because the
StringBuffer object never escapes the method and therefore can't be
accessed by other threads.

/Jesper Nordenberg

I did some timings on the different solutions using the following program

public class Test
{
 public static String fillString1(int size, char c)
 {
   StringBuffer b = new StringBuffer(size);
   for (int i=0; i < size; i++)
   {
     b.append(c);
   }
   return b.toString();
 }

 public static String fillString2(int size, char c)
 {
   StringBuffer b = new StringBuffer(size);
   synchronized (b)
   {
     for (int i=0; i < size; i++)
     {
       b.append(c);
     }
   }
   return b.toString();
 }

 public static String fillString3(int size, char c)
 {
   char[] b = new char[size];
   for (int i=0; i < size; i++)
   {
     b[i] = c;
   }
   return new String(b);
 }

 public static void main(String[] args)
 {
   long start, end;
   int count = 500000;
   int size = 50;
   char c = 'x';

   start = System.currentTimeMillis();
   for (int i=0; i < count; i++)
   {
     String s = fillString1(size, c);
   }
   end = System.currentTimeMillis();
   System.out.println("time1: " + (end - start));

   start = System.currentTimeMillis();
   for (int i=0; i < count; i++)
   {
     String s = fillString2(size, c);
   }
   end = System.currentTimeMillis();
   System.out.println("time2: " + (end - start));

   start = System.currentTimeMillis();
   for (int i=0; i < count; i++)
   {
     String s = fillString3(size, c);
   }
   end = System.currentTimeMillis();
   System.out.println("time3: " + (end - start));
 }
}

On my computer the version with the char[] is significantly faster then the
StringBuffer version:

time1: 1953
time2: 1462
time3: 330

It doesn't change too much when increasing the size of the generated string
(simply play around with the size parameter)

So the synchronization trick actually shows some performance gain.

Regards
Thomas

Because the value of "size" isn't going to be assigned
nondeterministically.