前言
我们都知道,String是不可变的,所以在字符串操作比较频繁的时候使用StringBuilder和StringBuffer运行效率更高。 StringBuilder和StringBuffer的区别在于StringBuilder是线程不安全的,而StringBuffer是线程安全的。
为什么呢,今天通过源码来一探究竟…
小试验
写一个小demo,开启10个线程,拼接字符串,并最终输出字符串长度
public static void main(String[] args) throws InterruptedException {
StringBuilder s = new StringBuilder();
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j < 1000; j++)
s.append("s");
}
}).start();
}
Thread.sleep(1000);
System.out.println(s.length());
}
输出结果:小于10000,同时还抛出异常ArrayIndexOutOfBoundsException,why?
Exception in thread "Thread-1" java.lang.ArrayIndexOutOfBoundsException
at java.lang.System.arraycopy(Native Method)
at java.lang.String.getChars(String.java:826)
at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:449)
at java.lang.StringBuilder.append(StringBuilder.java:136)
at StringTest$1.run(StringTest.java:10)
at java.lang.Thread.run(Thread.java:745)
9290
源码分析
我们进入源码来一探究竟,首先StringBuilder和StringBuffer都是继承于AbstractStringBuilder,都是通过一个char数组来存储字符串的。
/**
* The value is used for character storage.
*/
char[] value;
/**
* The count is the number of characters used.
*/
int count;
引申:String也是通过char数组来实现的,不同的是String里面的char数组被final修饰,是不可变的。
我们继续看StringBuilder是append()方法,调用的父类AbstractStringBuilder的append()方法。
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
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值是100,len为1,此时两个线程同时拿到了count都是100,执行完加法运算后将结果赋值给count,所以两个线程执行完之后,count值为101,而不是102。这就是为什么测试结果要小于预想的10000了。
那么为什么又会抛出ArrayIndexOutOfBoundsException异常呢?
我们继续看:
ensureCapacityInternal(count + len); //检查原char数组的容量能不能装下新的字符串
str.getChars(0, len, value, count);//将String对象的char数组里面的内容拷贝到StringBuilder对象的char数组里面
判断StringBuilder对象的char数组容量是否足够,不够的话需要进行扩容
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
扩容的逻辑就是new一个新的char数组,新的数组的容量为原来数组的两倍+2。
private int newCapacity(int minCapacity) {
// overflow-conscious code
int newCapacity = (value.length << 1) + 2;
....
}
str.getChars就是将String对象char数组的内容拷贝到StringBuilder对象char数组里面。
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
.....
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}
所以在拷贝的过程中可能会发生什么呢?
假设现在有两个线程同时执行了append()方法,同时执行到了ensureCapacityInternal()方法,此时count=10。
这个时候线程1的CPU时间片用完了,线程2继续执行。线程2执行完成整个append()方法之后count变成11了。
而线程1继续执行str.getChars()方法的时候拿到的count就是11了,执行char数组拷贝的时候就会抛出ArrayIndexOutOfBoundsException异常了。
StringBuilder为什么线程非安全分析完了,那如果使用StringBuffer呢?运行结果显然就等于10000,那么StringBuffer是如何实现线程安全的呢?
10000
我们继续看StringBuffer的append()方法,同样是调用的父类AbstractStringBuilder的append()方法,但细心的同学可能发现StringBuffer的append()方法的通过关键字的synchronized修饰,所以整个append()操作是线程同步的。
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
关于synchronized关键字我们后续再讲。
总结
所以为什么StringBuilder是线程不安全的:因为StringBuilder的append()方法是不同步。