一、String 字符串常量

String 是 不可变对象，每次对 String 对象进行改变都会生成一个新的 String 对象，然后将指针指向新的 String 对象，故经常改变内容的字符串最好不要用 String 。因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度就更加慢了。

package com.nobody.part01;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author Mr.nobody
 * @Description 测试String字符串拼接性能
 * @date 2020/9/17
 */
public class StringDemo {

    // 请求总数
    private static int CLIENT_COUNT = 10000;
    // 并发线程数
    private  static int THREAD_COUNT = 500;
    // 全局变量
    private static String STRING = new String();

    public static void main(String[] args) throws InterruptedException {
        // 固定线程池
        ExecutorService executorService = Executors.newFixedThreadPool(CLIENT_COUNT);
        // 控制同一个时刻，只能有多少个线程同时运行指定代码，即acquire和release之间的代码
        Semaphore semaphore = new Semaphore(THREAD_COUNT);
        CountDownLatch countDownLatch = new CountDownLatch(CLIENT_COUNT);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < CLIENT_COUNT; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    STRING += "0";
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        // 等待所有请求执行完
        countDownLatch.await();
        // 关闭线程池
        executorService.shutdown();
        long endTime = System.currentTimeMillis();
        System.out.println("String -- 总共耗时：" + (endTime - startTime) + "ms，字符串长度：" + STRING.length());
    }
}

二、StringBuffer 字符串变量

StringBuffer 是 可变对象，每次对 StringBuffer 对象进行改变都会对StringBuffer 对象本身进行操作。而不是生成新的对象，再改变对象引用。如果 StringBuffer 对象在多线程环境下，特别是字符串对象经常改变的情况下，推荐使用它 。因为 StringBuffer 几乎所有的方法都加了synchronized关键字，所以是线程安全的，但是性能会相对较差。

package com.nobody.part01;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author Mr.nobody
 * @Description 测试线程安全类StringBuffer
 * @date 2020/9/17
 */
public class StringBufferDemo {

    // 请求总数
    private static int CLIENT_COUNT = 10000;
    // 并发线程数
    private  static int THREAD_COUNT = 500;
    // 全局变量，线程安全StringBuffer
    private static StringBuffer STRINGBUFFER = new StringBuffer();

    public static void main(String[] args) throws InterruptedException {
        // 固定线程池
        ExecutorService executorService = Executors.newFixedThreadPool(CLIENT_COUNT);
        // 控制同一个时刻，只能有多少个线程同时运行指定代码，即acquire和release之间的代码
        Semaphore semaphore = new Semaphore(THREAD_COUNT);
        CountDownLatch countDownLatch = new CountDownLatch(CLIENT_COUNT);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < CLIENT_COUNT; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    STRINGBUFFER.append("0");
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        // 等待所有请求执行完
        countDownLatch.await();
        // 关闭线程池
        executorService.shutdown();
        long endTime = System.currentTimeMillis();
        System.out.println("StringBuffer -- 总共耗时：" + (endTime - startTime) + "ms，字符串长度：" + STRINGBUFFER.length());
    }
}

三、StringBuilder 字符串变量

StringBuilder 一个 可变的字符序列。StringBuilder 提供一个与 StringBuffer 兼容的 API，但不保证同步（即 线程不安全）。该类被设计用作 StringBuffer 的一个简易替换， 用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。在堆栈封闭等线程安全的环境下（方法中的局部变量）应该首选 StringBuilder。

package com.nobody.part01;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author Mr.nobody
 * @Description 测试线程不安全类StringBuilder
 * @date 2020/9/17
 */
public class StringBuilderDemo {

    // 请求总数
    private static int CLIENT_COUNT = 10000;
    // 并发线程数
    private  static int THREAD_COUNT = 500;
    // 全局变量，线程不安全StringBuilder
    private static StringBuilder STRINGBUILDER = new StringBuilder();

    public static void main(String[] args) throws InterruptedException {
        // 固定线程池
        ExecutorService executorService = Executors.newFixedThreadPool(CLIENT_COUNT);
        // 控制同一个时刻，只能有多少个线程同时运行指定代码，即acquire和release之间的代码
        Semaphore semaphore = new Semaphore(THREAD_COUNT);
        CountDownLatch countDownLatch = new CountDownLatch(CLIENT_COUNT);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < CLIENT_COUNT; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    STRINGBUILDER.append("0");
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        // 等待所有请求执行完
        countDownLatch.await();
        // 关闭线程池
        executorService.shutdown();
        long endTime = System.currentTimeMillis();
        System.out.println("StringBuilder -- 总共耗时：" + (endTime - startTime) + "ms，字符串长度：" + STRINGBUILDER.length());

    }
}

四、总结

• 对于不可变字符串或者字符串内容改变少的情况，推荐 String。
• 字符串对象可能会被多线程访问，并且经常改变内容，推荐 StringBuffer。
• 在堆栈封闭等线程安全的环境下（方法中的局部变量）推荐 StringBuilder。