为什么StringBuilder是线程不安全的

通常我们都知道说StringBuilder是线程不安全的，那如果继续追问下去，为什么StringBuilder是线程不安全的，该怎么回答呢？

首先需要明确地知道StringBuilder它内部的组织结构

1. 来看源代码中，StringBuilder的抽象父类AbstractStringBuilder的两个重要的成员变量

   /**
    * The value is used for character storage.
    * char数组存储使用的字符
    */
   char[] value;
   
   /**
    * The count is the number of characters used.
    * 使用的字符的数量
    */
   int count;
   

   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;
       }
   

   代码第五行是检查需要拼接的字符串长度跟已使用的字符长度之和是否超过char数组的长度，来决定是否扩容
   可以看一下具体的代码实现逻辑

   private void ensureCapacityInternal(int minimumCapacity) {
           // overflow-conscious code
           if (minimumCapacity - value.length > 0) {
               value = Arrays.copyOf(value,
                       newCapacity(minimumCapacity));
           }
       }
   

   还可以继续看一下扩容规则，newCapacity方法

   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;
       }
   

   第三行的意思就是扩容为原数组长度的2倍再加2，如果扩容之后的长度还是小于待拼接之后的长度，那直接使用待拼接之后的长度，后面的逻辑就是说，如果达到了最大容量的情况，这里不做讨论了，可以继续往下看源码，也是不难理解的

   接着回到append方法的第六行，str.getChars方法实现了将指定字符串拼接到char数组中
   可以看一下源码

   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);
       }
   

   前面是一系列参数校验，最后是调用一个native本地方法，System.arraycopy实现两个char数组从指定位置copy
   这里为什么是两个char数组中？
   因为String内部也是通过一个char数组维护字符串，只不过这个char数组成员变量是final修饰的

   继续回到append方法，第七行就是将成员变量count（使用的字符数量）加上拼接上的字符串长度

   至此完成append方法

2. 前面详细分析了StringBuilder的append方法，那为什么他就是线程不安全的呢？

   提供一个场景：

   现在char数组value的长度为5，已使用的字符数count为4
   
   线程1和线程2都运行到了append方法的第五行结束，都没有触发扩容

   现在线程2抢占到cpu时间片，运行第六行，将g拼接上，count=5，char数组已满，如图
   
   那这个时候线程1再来接着运行，append方法第六行，前面分析过了str.getChars方法最终会调用一个native本地方法，System.arraycopy，可以看一下源码
   
   线程1肯定会报ArrayIndexOutofBoundsException，这就是多线程情况下StringBuilder不安全问题

   看到这里应该就明白了吧，在多线程情况下，StringBuilder会出现拼接的时候发生异常导致的不安全问题

   

   这个异常其实不易出现，我运行了快十次才出现一次，就赶紧截图啦。

3. 还有一点线程不安全的情况：
   在append方法的第7行，如果两个线程同时运行到这里之前，拿到的count相同的，然后继续往下执行，这样的话到最后count的值必定会少算，这个通过测试结果也很好出现。

   public static void main(String[] args) throws InterruptedException {
           for (int i = 0; i < 100; i++) {
               new Thread(() -> {
                   for (int j = 0; j < 100; j++) {
                       str.append("a");
                   }
               }).start();
           }
           Thread.sleep(2000);
           System.out.println(str.length());
       }
   

   

4. 跟他相对的StringBuffer类就是一个线程安全的字符串类，可以看一下他的源代码append方法

   	@Override
       public synchronized StringBuffer append(String str) {
           toStringCache = null;
           super.append(str);
           return this;
       }
   

   都加了synchronized锁，所以肯定是线程安全的，但是效率肯定就是低啦。。

5. 总结：
   详细讲解了StringBuilder的append方法实现逻辑以及多线程情况下会出现的问题
   以上都是自己个人总结，源码分析以及图片说明，如有问题，谢谢指正