High Java CPU usage due to string concatenation: String concat(+) vs. StringBuffer or StringBuilder append()

Applications Manager | November 11, 2011 | 2 min read
You might know that the String concat(+) method is a costly operation compared to the StringBuffer or StringBuilder append() method. But you might not know the actual performance difference.

Let me show you the performance difference with a simple test program:

  1. package test;
  3. public class StrVsBuffVsBuild {
  5.         public static void main(String[] args) {
  7.                 int count=200000;
  8.                 System.out.println(“Number of Strings concat Operation is \'”+count+”\'”);
  9.                 long st = System.currentTimeMillis();
  10.                 String str = “”;
  11.                 for (int i = 0; i < count; i++) {
  12.                         str += “MyString”;
  13.                 }
  14.                 System.out.println(“Time taken for String concat (+) Operation is \'”+(System.currentTimeMillis()-st)+”\’ Millis”);
  15.                 st = System.currentTimeMillis();
  16.                 StringBuffer sb = new StringBuffer();
  17.                 for (int i = 0; i < count; i++) {
  18.                         sb.append(“MyString”);
  19.                 }
  20.                 System.out.println(“Time taken for StringBuffer.append() Operation is \'”+(System.currentTimeMillis()-st)+”\’ Millis”);
  21.                 st = System.currentTimeMillis();
  22.                 StringBuilder sbr = new StringBuilder();
  23.                 for (int i = 0; i < count; i++) {
  24.                         sbr.append(“MyString”);
  25.                 }
  26.                 System.out.println(“Time taken for StringBuilder.append() Operation is \'”+(System.currentTimeMillis()-st)+”\’ Millis”);
  27.         }
  28. }

Here is the output of the above test program:

Number of Strings concat Operation is ‘200000’
Time taken for String concat (+) Operation is ‘373933’ Millis
Time taken for StringBuffer.append() Operation is ’19’ Millis

Time taken for StringBuilder.append() Operation is ‘5’ Millis

The String concat (+) method took 6.2 minutes, while StringBuffer and StringBuilder append() took only 19 and 5 milliseconds, respectively. Is it comparable? Moreover, during the entire 6.2-minute execution of the String concat() operation, the Java process took 100% CPU usage. You can see the CPU usage of the m/c and Java program in the graphs below:

 

So, use StringBuilder or StringBuffer append() instead of String concat(+). Your next question might be “Which one is better, StringBuffer or StringBuilder?” Since the StringBuffer methods are synchronized, it is safe if the code is accessed by multiple threads. The StringBuilder methods are not synchronized, so it is not thread-safe. So if you need to append a global variable that can be accessed by multiple threads, you should use StringBuffer. If it is a method-level variable that cannot be accessed by multiple threads, you should use StringBuilder. Due to the absence of synchronization, StringBuilder is faster than StringBuffer.

rameshj@zohocorp.com