How do I prove programmatically that StringBuilder is not threadsafe?


I am afraid the test you have written is incorrect.

The main requirement is to share the same StringBuilder instance between different threads. Whereas you are creating a StringBuilder object for each thread.

The problem is that a new Threadsafe() initialises a new StringBuilder():

class Threadsafe {
    StringBuilder sb = new StringBuilder(str);
class MyThread1 implements Runnable {
    Threadsafe sf = new Threadsafe();
class MyThread2 implements Runnable {
    Threadsafe sf = new Threadsafe();


To prove the StringBuilder class is not thread-safe, you need to write a test where n threads (n > 1) append some stuff to the same instance simultaneously.

Being aware of the size of all the stuff you are going to append, you will be able to compare this value with the result of builder.toString().length():

final long SIZE = 1000;         // max stream size

final StringBuilder builder = Stream
        .generate(() -> "a")    // generate an infinite stream of "a"
        .limit(SIZE)            // make it finite
        .parallel()             // make it parallel
        .reduce(new StringBuilder(), StringBuilder::append, (b1, b2) -> b1);
                                // put each element in the builder

Assert.assertEquals(SIZE, builder.toString().length());

Since it is actually not thread-safe, you may have trouble getting the result.

An ArrayIndexOutOfBoundsException may be thrown because of the char[] AbstractStringBuilder#value array and the allocation mechanism which was not designed for multithreading use.


Here is my JUnit 5 test which covers both StringBuilder and StringBuffer:

public class AbstractStringBuilderTest {

    public void testStringBuilder() {
        testAbstractStringBuilder(new StringBuilder(), StringBuilder::append);

    public void testStringBuffer() {
        testAbstractStringBuilder(new StringBuffer(), StringBuffer::append);

    private <T extends CharSequence> void testAbstractStringBuilder(T builder, BiFunction<T, ? super String, T> accumulator) {
        final long SIZE = 1000;
        final Supplier<String> GENERATOR = () -> "a";

        final CharSequence sequence = Stream
                .reduce(builder, accumulator, (b1, b2) -> b1);

                SIZE * GENERATOR.get().length(),    // expected
                sequence.toString().length()        // actual



    10000 total, 165 error, 5988 failed, 3847 passed.

    10000 total, 10000 passed.

Leave a Comment