Why Java uses StringBuffer (synchronized) when StringBuilder is faster?

Question

I was looking at the Java reflection classes and noticed this piece of code. Made me wonder, why Java uses StringBuffer when StringBuilder is faster?

Wouldn't Java want to use the fastest implementation, or is there some other reason?

The code is in the Field.class:

static String getTypeName(Class<?> type) {
    if (type.isArray()) {
        try {
            Class<?> cl = type;
            int dimensions = 0;
            while (cl.isArray()) {
                dimensions++;
                cl = cl.getComponentType();
            }
            StringBuffer sb = new StringBuffer();
            sb.append(cl.getName());
            for (int i = 0; i < dimensions; i++) {
                sb.append("[]");
            }
            return sb.toString();
        } catch (Throwable e) { /*FALLTHRU*/ }
    }
    return type.getName();
}

It might be written before Java5 (or someone who did not know Java5 at moment of writing)? — Maja Piechotka
– Maja Piechotka, Commented Aug 10, 2012 at 21:42
You would have to ask the authors. Anything you read here will be just guesswork. Not constructive. — user207421
– user207421, Commented Aug 11, 2012 at 2:15

Dunes · Accepted Answer · 2012-08-10 22:41:41Z

4

The main reason is that the JVM has advanced techniques to see if can avoid having to do all sorts of things are they are implied by the context. Since the StringBuffer is a local variable that never escapes the method the JVM can safely avoid having to try and acquire a lock on the object before entering the StringBuffer's synchronised methods -- since no other thread will ever be able to call the methods of this particular instance of StringBuffer.

A quick micro benchmark bears this out. Making buffer a field will slow down the following code by 50%.

private void doTest(String toCopy) {
    StringBuffer buffer = new StringBuffer();
    for (int i = 0; i < toCopy.length(); i++) {
        buffer.append(toCopy.charAt(i));
    }
    buffer.toString();
}

With a million length string and 1000 repetitions the above code runs in 8 seconds on my machine. However, once buffer is made into a field rather than a local variable then it takes about 13 seconds (Since the JVM can no longer easily guarantee that buffer will only be accessed by one thread).

edited Aug 10, 2012 at 22:41

answered Aug 10, 2012 at 21:51

Dunes

42.1k7 gold badges86 silver badges107 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

user207421 Over a year ago

This might or might not be the reason why the code was written that way. Do you have some evidence about that?

Dunes Over a year ago

infoq.com/articles/java-threading-optimizations-p1 shows some optmisations performed by the JVM with relation to threading issues (including escape analysis). As a side note my micro-benchmark performs exactly the same when using a StringBuffer as when using a StringBuilder.

tskuzzy · Accepted Answer · 2012-08-10 21:50:01Z

4

StringBuffer has been around since JDK 1.0.

Field came around pre-1.4.2.

Finally StringBuilder made its way in Java 1.5.

answered Aug 10, 2012 at 21:50

tskuzzy

36.6k15 gold badges78 silver badges145 bronze badges

1 Comment

user207421 Over a year ago

Field appeared with Reflection in 1.2.

JTMon · Accepted Answer · 2012-08-10 21:44:25Z

2

If memory serves me right Stringbuffer was introduced first so this might be an older piece of code. The Real reason would have to be thread safety though as stringbuilder is not therad safe while the buffer is.

answered Aug 10, 2012 at 21:44

JTMon

3,19924 silver badges24 bronze badges

Comments

Peter Lawrey · Accepted Answer · 2012-08-11 07:30:15Z

I have met and asked a couple of the JVM developers why there is still so much use of StringBuffer since they recommended people migrate to StringBuilder as a drop in replacement 8 years ago. I got the impression it not something which they have worried/thought about. There was no official reason from one of the product managers.

I think its up there with why the JDK source uses tabs when the Java Coding Convention (1999) suggested you should use spaces. The fix is trivial using a code formatter, but its not on anyones todo list.

IMHO StringBuffer was never a good idea to make multi-threaded in the first place. In the rare cases you might want to write to an in memory stream of characters in a multi-thread way and you didn't care how jumbled up the text it produced was, you can still use more natural alternatives like StringWriter (which wasn't available in Java 1.0) or synchronize a StringBuilder.

I believe it actually cased a lot of bugs e.g. SimpleDateFormat used it and still uses StringBuffer to some degree even though its not thread safe. It may have given some developers a false sense of security using a thread safe collection or looked sort of thread safe. i.e. Using StringBuffer rather than StringBuilder in multiple threads is more likely to pass simple tests even thought there might be a bug.

e.g. Consider two threads writing

sb.append("Hello ").append("World").append("\n");

The problem is that while each append is synchronized, each block of code is not. SO you can get

Hello Hello World World\n\n

or

Hello World Hello \nWorld\n

So StringBuffer is only thread safe without synchronization if you only use append once which makes it rather pointless.

I try to point out to people to switch when questions involving StringBuffer are posted on SO.

Collectives™ on Stack Overflow

Why Java uses StringBuffer (synchronized) when StringBuilder is faster?

4 Answers 4

2 Comments

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related