一、简述
StringBuilder 和 StringBuffer 的内部实现跟 String 一样，都是通过 char[] 存储字符串。不同的是 String 里面的 char[] 是 final 修饰的，是不可变的，而 StringBuilder 和 StringBuffer 的 char[] 是可变的。StringBuilder 不是线程安全的，StringBuffer 是线程安全的。看一下多线程操作 StringBuilder 对象会出现什么问题：
public static void main(String[] args) throws InterruptedExcept
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j < 1000; j++) {
stringBuilder.append("a");
}
}
}).start();
}
Thread.sleep(100);
System.out.println(stringBuilder.length());
}
结果小于预期的 10000，并且还抛出了一个ArrayIndexOutOfBoundsException(异常不是必现)。
二、为什么输出值跟预期值不一样
1️⃣StringBuilder 的两个成员变量(这两个成员变量实际上是定义在 AbstractStringBuilder 里面的，StringBuilder 和 StringBuffer 都继承了 AbstractStringBuilder)：
/**
* The value is used for character storage.
*/
char[] value;
/**
* The count is the number of characters used.
*/
int count;
2️⃣再看 StringBuilder 的 append()：
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
3️⃣StringBuilder 的 append() 调用的父类 AbstractStringBuilder 的 append()：
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
先不管代码的第五行和第六行干了什么，直接看第七行，count += len不是一个原子操作。假设这个时候 count 值为 10，len 值为 1，两个线程同时执行到了第七行，拿到的 count 值都是 10，执行完加法运算后将结果赋值给 count，所以两个线程执行完后 count 值为 11，而不是 12。这就是为什么测试代码输出的值要比 10000 小的原因。
三、为什么会抛出ArrayIndexOutOfBoundsException
看 AbstractStringBuilder 的 append() 的第五行ensureCapacityInternal(count + len);是检查 StringBuilder 对象的原 char[] 的容量能不能盛下新的字符串，如果盛不下就调用ensureCapacityInternal(int minimumCapacity)对 char[] 进行扩容。
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
扩容的逻辑就是 new 一个新的 char[]，新的 char[] 的容量是原来 char[] 的两倍再加 2，再通过 System.arryCopy() 将原数组的内容复制到新数组，最后将指针指向新的 char[]。扩容逻辑：
private int newCapacity(int minCapacity) {
// overflow-conscious code
int newCapacity = (value.length << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
? hugeCapacity(minCapacity)
: newCapacity;
}
AbstractStringBuilder 的 append() 的第六行str.getChars(0, len, value, count);是将 String 对象里面 char[] 里面的内容拷贝到 StringBuilder 对象的 char[] 里面，getChars()：
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
if (srcBegin < 0) {
throw new StringIndexOutOfBoundsException(srcBegin);
}
if (srcEnd > value.length) {
throw new StringIndexOutOfBoundsException(srcEnd);
}
if (srcBegin > srcEnd) {
throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
}
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}
线程一继续执行第六行的 str.getChars() 的时候拿到的 count 值就是 6 了，执行 char 数组拷贝的时候就会抛出 ArrayIndexOutOfBoundsException。