JAVA面试题 从源码角度分析StringBuffer和StringBuilder的区别

public void ensureCapacity(int minimumCapacity) {
 if (minimumCapacity > 0)
  ensureCapacityInternal(minimumCapacity);
}
 
/**
* 确保value字符数组不会越界.重新new一个数组,引用指向value
*/ 
private void ensureCapacityInternal(int minimumCapacity) {
 // overflow-conscious code
 if (minimumCapacity - value.length > 0) {
  value = Arrays.copyOf(value,
    newCapacity(minimumCapacity));
 }
}
 
/**
* 扩容:将长度扩展到之前大小的2倍+2
*/ 
private int newCapacity(int minCapacity) {
 // overflow-conscious code 扩大2倍+2
 //这里可能会溢出,溢出后是负数哈,注意
 int newCapacity = (value.length << 1) + 2;
 if (newCapacity - minCapacity < 0) {
  newCapacity = minCapacity;
 }
 //MAX_ARRAY_SIZE的值是Integer.MAX_VALUE - 8,先判断一下预期容量(newCapacity)是否在0<x<MAX_ARRAY_SIZE之间,在这区间内就直接将数值返回,不在这区间就去判断一下是否溢出
 return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
  ? hugeCapacity(minCapacity)
  : newCapacity;
}
 
/**
* 判断大小，是否溢出
*/
private int hugeCapacity(int minCapacity) {
 if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
  throw new OutOfMemoryError();
 }
 return (minCapacity > MAX_ARRAY_SIZE)
  ? minCapacity : MAX_ARRAY_SIZE;
}

@Override
public synchronized StringBuffer append(long lng) {
 toStringCache = null;
 super.append(lng);
 return this;
}
 
/**
 * @throws StringIndexOutOfBoundsException {@inheritDoc}
 * @since  1.2
 */
@Override
public synchronized StringBuffer replace(int start, int end, String str) {
 toStringCache = null;
 super.replace(start, end, str);
 return this;
}
 
/**
 * @throws StringIndexOutOfBoundsException {@inheritDoc}
 * @since  1.2
 */
@Override
public synchronized String substring(int start) {
 return substring(start, count);
}
 
@Override
public synchronized String toString() {
 if (toStringCache == null) {
  toStringCache = Arrays.copyOfRange(value, 0, count);
 }
 return new String(toStringCache, true);
}

@Override
public StringBuilder append(double d) {
 super.append(d);
 return this;
}
 
/**
 * @since 1.5
 */
@Override
public StringBuilder appendCodePoint(int codePoint) {
 super.appendCodePoint(codePoint);
 return this;
}
 
/**
 * @throws StringIndexOutOfBoundsException {@inheritDoc}
 */
@Override
public StringBuilder delete(int start, int end) {
 super.delete(start, end);
 return this;
}

import java.util.concurrent.CountDownLatch;
 
public class TestStringBuilderAndStringBuffer {
 public static void main(String[] args) {
  //证明StringBuffer线程安全，StringBuilder线程不安全
  StringBuffer stringBuffer = new StringBuffer();
  StringBuilder stringBuilder = new StringBuilder();
  CountDownLatch latch1 = new CountDownLatch(1000);
  CountDownLatch latch2 = new CountDownLatch(1000);
  for (int i = 0; i < 1000; i++) {
   new Thread(new Runnable() {
    @Override
    public void run() {
     try {
      stringBuilder.append(1);
     } catch (Exception e) {
      e.printStackTrace();
     } finally {
      latch1.countDown();
     }
    }
   }).start();
  }
  for (int i = 0; i < 1000; i++) {
   new Thread(new Runnable() {
    @Override
    public void run() {
     try {
      stringBuffer.append(1);
     } catch (Exception e) {
      e.printStackTrace();
     } finally {
      latch2.countDown();
     }
 
    }
   }).start();
  }
  try {
   latch1.await();
   System.out.println(stringBuilder.length());
   latch2.await();
   System.out.println(stringBuffer.length());
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
}