如何以编程方式证明 StringBuilder 不是线程安全的？
Posted
技术标签:
【中文标题】如何以编程方式证明 StringBuilder 不是线程安全的？【英文标题】：How do I prove programmatically that StringBuilder is not threadsafe? 【发布时间】：2018-07-11 12:33:31 【问题描述】：如何以编程方式证明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();
【问题讨论】：
只是好奇：为什么你想证明某事不是线程安全的？Threadsafe sf = new Threadsafe()（在您的两个线程类中）=> 这意味着您的两个线程在不同的 Threadsafe 实例上运行，因此在不同的 StringBuilder 实例上运行！
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"。它被记录为不是线程安全的。您可能无法证明它不是线程安全的，因为实现可能已经更改，因此它是；但是，您不应该依赖该属性，因为不能保证它会继续是线程安全的。
@MickMnemonic 可能是因为一些同事声称他们使用 StringBuilder 的多线程代码是完全安全的，而问题作者想证明他们是错误的。
一个主要警告：并发问题往往难以捉摸。即使该类不是线程安全的，您也可能不会遇到错误。有时很难找到此类错误。
【参考方案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());
由于它实际上不是线程安全的，因此您可能无法获得结果。
ArrayIndexOutOfBoundsException 可能会因为 char[] AbstractStringBuilder#value 数组和不是为多线程使用而设计的分配机制而被抛出。
测试
这是我的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.
【讨论】：
哇，这比我在StringBuilder 案例中预期的错误和失败率要高得多。多么好的演示。
使用并行流而不是直接使用线程是个好主意。这使得测试时间更短。
@JohnBollinger 在我的系统上，失败率更高，>9900...
@Holger，看到这么低的失败率我也很惊讶，你有没有使用任何 JVM 标志？
@AndrewTobilko 不，只有 8 核 Windows 上的 64 位 JVM；无需特殊设置。【参考方案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 个元素（但无序）。
【讨论】：
虽然这可能有效，但它没有解释为什么 OP 的代码确实证明相反。 OP 只要求提供证明； OP 从未问过为什么他们的代码不起作用 @WordsLikeJared：是的，但这种解释使它成为一个更好的答案。查看 Andrew 高度评价的答案【参考方案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());
这是为了通过proof by contradiction 方法证明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 被多个线程使用时会损坏。
【讨论】：
虽然这可能有效，但它没有解释为什么 OP 的代码确实证明相反。 @ThomasWeller 标题中提出的问题是如何证明它已损坏，而不是为什么操作中的代码会显示问题 @Ferrybig：是的，但这种解释使它成为一个更好的答案。查看 Andrew 高度评价的答案以上是关于如何以编程方式证明 StringBuilder 不是线程安全的？的主要内容，如果未能解决你的问题，请参考以下文章