如何通过编程证明StringBuilder不是线程安全的？

Question

如何在程序中证明StringBuilder不是线程安全的？

我尝试了以下代码，但它并没有起到作用：

public class Threadsafe {
    public static void main(String[] args) throws InterruptedException {
        long startdate = System.currentTimeMillis();

        MyThread1 mt1 = new MyThread1();
        Thread t = new Thread(mt1);
        MyThread2 mt2 = new MyThread2();
        Thread t0 = new Thread(mt2);
        t.start();
        t0.start();
        t.join();
        t0.join();
        long enddate = System.currentTimeMillis();
        long time = enddate - startdate;
        System.out.println(time);
    }

    String str = "aamir";
    StringBuilder sb = new StringBuilder(str);

    public void updateme() {
        sb.deleteCharAt(2);
        System.out.println(sb.toString());
    }

    public void displayme() {
        sb.append("b");
        System.out.println(sb.toString());
    }
}

class MyThread1 implements Runnable {
    Threadsafe sf = new Threadsafe();

    public void run() {
        sf.updateme();
    }
}

class MyThread2 implements Runnable {
    Threadsafe sf = new Threadsafe();

    public void run() {
        sf.displayme();
    }
}

- Aamir Mohammed suhail

---

只是好奇：你为什么想要证明某个东西不是线程安全的？ - Mick Mnemonic

Threadsafe sf = new Threadsafe() （在您的两个线程类中）=> 这意味着，您的两个线程正在操作不同的Threadsafe实例，因此是不同的StringBuilder实例！ - Seelenvirtuose

curl https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html | grep "not safe for use by multiple threads" && echo "Not thread safe"的含义是：该文档记录了StringBuilder类不支持多线程使用。尽管实现可能已更改，变得支持多线程使用，但是不能保证其一定是线程安全的，因此不应该依赖它具有线程安全的属性。 - Andy Turner

很可能是因为某位同事声称他们使用StringBuilder编写的多线程代码完全安全，而问题提出者想证明他们是错的。 - Philipp

一个主要的警告：并发问题往往是难以捉摸的。即使类不是线程安全的，您可能也不会遇到错误。有时候找到这样的错误非常困难。 - Peter - Reinstate Monica

Answer 1

问题

很抱歉，您编写的测试不正确。

主要要求是在不同的线程之间共享相同的StringBuilder实例。而您正在为每个线程创建一个StringBuilder对象。

问题在于new Threadsafe()初始化了一个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();
    ...
}

说明

为了证明StringBuilder类不是线程安全的，您需要编写一个测试，在该测试中，n个线程（n > 1）同时向同一实例追加一些内容。

了解您要追加的所有内容的大小，您将能够将此值与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());

由于它实际上不是线程安全的，因此您可能会在获取结果时遇到麻烦。

由于char[] AbstractStringBuilder#value数组和分配机制不是为多线程使用而设计的，因此可能会抛出ArrayIndexOutOfBoundsException异常。

测试

这是我的JUnit 5测试，涵盖了StringBuilder和StringBuffer：

public class AbstractStringBuilderTest {

    @RepeatedTest(10000)
    public void testStringBuilder() {
        testAbstractStringBuilder(new StringBuilder(), StringBuilder::append);
    }

    @RepeatedTest(10000)
    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
                .generate(GENERATOR)
                .parallel()
                .limit(SIZE)
                .reduce(builder, accumulator, (b1, b2) -> b1);

         Assertions.assertEquals(
                SIZE * GENERATOR.get().length(),    // expected
                sequence.toString().length()        // actual
         );
    }

}

结果

AbstractStringBuilderTest.testStringBuilder: 
    10000 total, 165 error, 5988 failed, 3847 passed.

AbstractStringBuilderTest.testStringBuffer:
    10000 total, 10000 passed.

- Andrew Tobilko

---

哇，StringBuilder 的错误和失败率比我预期的要高得多。这是一个很好的演示。 - John Bollinger

使用并行流而不是直接使用线程，是个好主意。这会使测试时间缩短许多。 - user253751

@JohnBollinger 在我的系统中，失败率甚至更高，>9900... - Holger

@Holger，我也很惊讶看到如此低的失败率，你使用了任何JVM标志吗？ - Andrew Tobilko

@AndrewTobilko 不，只是在 Windows 上使用 64 位 JVM 和 8 个核心；没有特殊的设置。 - Holger

Answer 2

更简单的写法：

StringBuilder sb = new StringBuilder();
IntStream.range(0, 10)
         .parallel()
         .peek(sb::append) // don't do this! just to prove a point...
         .boxed()
         .collect(Collectors.toList());

if (sb.toString().length() != 10) {
    System.out.println(sb.toString());
}

数字的顺序没有规定（不会是012...等等），但这并不重要。您关心的是，范围[0..10]中的并非全部数字都被添加到了StringBuilder中。

另一方面，如果您将StringBuilder替换为StringBuffer，则该缓冲区始终包含10个元素（但顺序不同）。

- Eugene

---

虽然这样做可能有效，但它忽略了解释为什么OP的代码证明了相反的结果。 - Thomas Weller

OP只是要求证明；OP从未问过他们的代码为什么不起作用。 - Jesus is Lord

@WordsLikeJared：没错，但这个解释使它成为更好的答案。可以看看Andrew得到高赞的回答。 - Thomas Weller

Answer 3

考虑以下测试。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

public class NotThreadSafe {

    private static final int CHARS_PER_THREAD = 1_000_000;
    private static final int NUMBER_OF_THREADS = 4;

    private StringBuilder builder;

    @Before
    public void setUp() {
        builder = new StringBuilder();
    }

    @Test
    public void testStringBuilder() throws ExecutionException, InterruptedException {
        Runnable appender = () -> {
            for (int i = 0; i < CHARS_PER_THREAD; i++) {
                builder.append('A');
            }
        };
        ExecutorService executorService = Executors.newFixedThreadPool(NUMBER_OF_THREADS);
        List<Future<?>> futures = new ArrayList<>();
        for (int i = 0; i < NUMBER_OF_THREADS; i++) {
            futures.add(executorService.submit(appender));
        }
        for (Future<?> future : futures) {
            future.get();
        }
        executorService.shutdown();
        String builtString = builder.toString();
        Assert.assertEquals(CHARS_PER_THREAD * NUMBER_OF_THREADS, builtString.length());
    }
}

这旨在通过反证法的方法证明StringBuilder不是线程安全的。当运行时，它总是会抛出如下的异常：

java.util.concurrent.ExecutionException: java.lang.ArrayIndexOutOfBoundsException: 73726

    at java.util.concurrent.FutureTask.report(FutureTask.java:122)
    at java.util.concurrent.FutureTask.get(FutureTask.java:192)
    at NotThreadSafe.testStringBuilder(NotThreadSafe.java:37)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
    at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
    at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
    at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
Caused by: java.lang.ArrayIndexOutOfBoundsException: 73726
    at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:650)
    at java.lang.StringBuilder.append(StringBuilder.java:202)
    at NotThreadSafe.lambda$testStringBuilder$0(NotThreadSafe.java:28)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
    at java.util.concurrent.FutureTask.run(FutureTask.java:266)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    at java.lang.Thread.run(Thread.java:748)

因此，当被多个线程使用时，{{StringBuilder}} 会出现问题。

- alxg2112

---

虽然这可能有效，但它忽略了解释为什么 OP 的代码证明了相反的结果。 - Thomas Weller

题目中所问是如何证明代码已经出现问题，而不是为什么原作者的代码演示了这个问题。请问需要翻译其他内容吗？ - Ferrybig

@Ferrybig：没错，但这个解释使它成为更好的答案。请看Andrew所得到的高赞答案。 - Thomas Weller