一、业务开发缺陷

        ① 工期紧、逻辑复杂，开发人员会更多地考虑主流程逻辑的正确实现，忽略非主流程逻辑，或保障、补偿、一致性逻辑的实现；

        ②  往往缺乏详细的设计、监控和容量规划的闭环，结果就是随着业务发展出现各种各样的事故。

二、学习方法

        ① 对于每一个坑点，实际运行调试一下源码，使用文中提到的工具和方法重现问题，眼见为实。

        ② 对于每一个坑点，再思考下除了文内的解决方案和思路外，是否还有其他修正方式。

        ③ 对于坑点根因中涉及的 JDK 或框架源码分析，你可以找到相关类再系统阅读一下源码。

        ④ 实践课后思考题。这些思考题，有的是对文章内容的补充，有的是额外容易踩的坑。

三、如何尽量避免踩坑

        ① 遇到自己不熟悉的新类，在不了解之前不要随意使用

                例如：CopyOnWriteArrayList 是 ArrayList 的线程安全版本，在不知晓原理之前把它用于大量写操作的场景，那么很可能会遇到性能问题。

        ② 尽量使用更高层次的框架

                而高层次的框架，则会更多地考虑怎么方便开发者开箱即用

        ③ 关注各种框架和组件的安全补丁和版本更新

                我们使用的 Tomcat 服务器、序列化框架等，就是黑客关注的安全突破口

        ④ 尽量少自己造轮子，使用流行的框架

                因此使用 Netty 开发 NIO 网络程序，不但简单而且可以少踩很多坑

        ⑤ 开发的时候遇到错误，除了搜索解决方案外，更重要的是理解原理

        ⑥ 网络上的资料有很多，但不一定可靠，最可靠的还是官方文档

        ⑦ 做好单元测试和性能测试

        ⑧ 做好设计评审和代码审查工作

        ⑨ 借助工具帮我们避坑

        ⑩ 做好完善的监控报警

        如果一开始我们就可以对应用程序的内存使用、文件句柄使用、IO 使用量、网络带宽、TCP 连接、线程数等各种指标进行监控，并且基于合理阈值设置报警，那么可能就能在事故的婴儿阶段及时发现问题、解决问题。                

        在遇到报警的时候，我们不能凭经验想当然地认为这些问题都是已知的，对报警置之不理。我们要牢记，所有报警都需要处理和记录

四、并发工具类库的线程安全问题

1、没有意识到线程重用导致用户信息错乱的 Bug

错误示例：单线程存储查看用户信息会取到错误数据

private static final ThreadLocal<Integer> currentUser = ThreadLocal.withInitial(() -> null);@GetMapping("wrong")
public Map wrong(@RequestParam("userId") Integer userId) {//设置用户信息之前先查询一次ThreadLocal中的用户信息String before  = Thread.currentThread().getName() + ":" + currentUser.get();//设置用户信息到ThreadLocalcurrentUser.set(userId);//设置用户信息之后再查询一次ThreadLocal中的用户信息String after  = Thread.currentThread().getName() + ":" + currentUser.get();//汇总输出两次查询结果Map result = new HashMap();result.put("before", before);result.put("after", after);return result;
}

         原因：线程池会重用固定的几个线程，一旦线程重用，那么很可能首次从 ThreadLocal 获取的值是之前其他用户的请求遗留的值。这时，ThreadLocal 中的用户信息就是其他用户的信息。

正确用法：使用类似 ThreadLocal 工具来存放一些数据时，在代码运行完后清空设置的数据

private static final ThreadLocal currentUser = ThreadLocal.withInitial(() -> null);@GetMapping("right")
public Map right(@RequestParam("userId") Integer userId) {String before  = Thread.currentThread().getName() + ":" + currentUser.get();currentUser.set(userId);try {String after = Thread.currentThread().getName() + ":" + currentUser.get();Map result = new HashMap();result.put("before", before);result.put("after", after);return result;} finally {//在finally代码块中删除ThreadLocal中的数据，确保数据不串currentUser.remove();}
}

2、使用了线程安全的并发工具，并不代表解决了所有线程安全问题

        场景：有一个含 900 个元素的 Map，现在再补充 100 个元素进去，这个补充操作由 10 个线程并发进行

错误示例：在每一个线程的代码逻辑中先通过 size 方法拿到当前元素数量，计算ConcurrentHashMap 目前还需要补充多少元素，并在日志中输出了这个值，然后通过 putAll 方法把缺少的元素添加进去。

//线程个数
private static int THREAD_COUNT = 10;
//总元素数量
private static int ITEM_COUNT = 1000;//帮助方法，用来获得一个指定元素数量模拟数据的ConcurrentHashMap
private ConcurrentHashMap<String, Long> getData(int count) {return LongStream.rangeClosed(1, count).boxed().collect(Collectors.toConcurrentMap(i -> UUID.randomUUID().toString(), Function.identity(),(o1, o2) -> o1, ConcurrentHashMap::new));
}@GetMapping("wrong")
public String wrong() throws InterruptedException {ConcurrentHashMap<String, Long> concurrentHashMap = getData(ITEM_COUNT - 100);//初始900个元素log.info("init size:{}", concurrentHashMap.size());ForkJoinPool forkJoinPool = new ForkJoinPool(THREAD_COUNT);//使用线程池并发处理逻辑forkJoinPool.execute(() -> IntStream.rangeClosed(1, 10).parallel().forEach(i -> {//查询还需要补充多少个元素int gap = ITEM_COUNT - concurrentHashMap.size();log.info("gap size:{}", gap);//补充元素concurrentHashMap.putAll(getData(gap));}));//等待所有任务完成forkJoinPool.shutdown();forkJoinPool.awaitTermination(1, TimeUnit.HOURS);//最后元素个数会是1000吗？log.info("finish size:{}", concurrentHashMap.size());return "OK";
}

从日志中可以看到：

        初始大小 900 符合预期，还需要填充 100 个元素。

        worker1 线程查询到当前需要填充的元素为 36，竟然还不是 100 的倍数。

        worker13 线程查询到需要填充的元素数是负的，显然已经过度填充了。

        最后 HashMap 的总项目数是 1536，显然不符合填充满 1000 的预期。

原因：

        ① ConcurrentHashMap 只能保证提供的原子性读写操作是线程安全的

        ② 使用了 ConcurrentHashMap，不代表对它的多个操作之间的状态是一致的，是没有其他线程在操作它的，如果需要确保需要手动加锁。

        ③ 诸如 size、isEmpty 和 containsValue 等聚合方法，在并发情况下可能会反映 ConcurrentHashMap 的中间状态。因此在并发情况下，这些方法的返回值只能用作参考，而不能用于流程控制。显然，利用 size 方法计算差异值，是一个流程控制。

        ④ 诸如 putAll 这样的聚合方法也不能确保原子性，在 putAll 的过程中去获取数据可能会获取到部分数据。

解决方案：整段逻辑加锁即可

@GetMapping("right")
public String right() throws InterruptedException {ConcurrentHashMap<String, Long> concurrentHashMap = getData(ITEM_COUNT - 100);log.info("init size:{}", concurrentHashMap.size());ForkJoinPool forkJoinPool = new ForkJoinPool(THREAD_COUNT);forkJoinPool.execute(() -> IntStream.rangeClosed(1, 10).parallel().forEach(i -> {//下面的这段复合逻辑需要锁一下这个ConcurrentHashMapsynchronized (concurrentHashMap) {int gap = ITEM_COUNT - concurrentHashMap.size();log.info("gap size:{}", gap);concurrentHashMap.putAll(getData(gap));}}));forkJoinPool.shutdown();forkJoinPool.awaitTermination(1, TimeUnit.HOURS);log.info("finish size:{}", concurrentHashMap.size());return "OK";
}

        重新调用接口，程序的日志输出结果符合预期：

        ConcurrentHashMap 提供了一些原子性的简单复合逻辑方法，用好这些方法就可以发挥其威力。

3、没有充分了解并发工具的特性，从而无法发挥其威力

        场景：使用 Map 来统计 Key 出现次数的场景

        使用 ConcurrentHashMap 来统计，Key 的范围是 10。

        使用最多 10 个并发，循环操作 1000 万次，每次操作累加随机的 Key。

        如果 Key 不存在的话，首次设置值为 1。

//循环次数
private static int LOOP_COUNT = 10000000;
//线程数量
private static int THREAD_COUNT = 10;
//元素数量
private static int ITEM_COUNT = 10;
private Map<String, Long> normaluse() throws InterruptedException {ConcurrentHashMap<String, Long> freqs = new ConcurrentHashMap<>(ITEM_COUNT);ForkJoinPool forkJoinPool = new ForkJoinPool(THREAD_COUNT);forkJoinPool.execute(() -> IntStream.rangeClosed(1, LOOP_COUNT).parallel().forEach(i -> {//获得一个随机的KeyString key = "item" + ThreadLocalRandom.current().nextInt(ITEM_COUNT);synchronized (freqs) {      if (freqs.containsKey(key)) {//Key存在则+1freqs.put(key, freqs.get(key) + 1);} else {//Key不存在则初始化为1freqs.put(key, 1L);}}}));forkJoinPool.shutdown();forkJoinPool.awaitTermination(1, TimeUnit.HOURS);return freqs;
}

        直接通过锁的方式锁住 Map，然后做判断、读取现在的累计值、加 1、保存累加后值的逻辑。这段代码在功能上没有问题，但无法充分发挥 ConcurrentHashMap 的威力

  优化方案：

private Map<String, Long> gooduse() throws InterruptedException {ConcurrentHashMap<String, LongAdder> freqs = new ConcurrentHashMap<>(ITEM_COUNT);ForkJoinPool forkJoinPool = new ForkJoinPool(THREAD_COUNT);forkJoinPool.execute(() -> IntStream.rangeClosed(1, LOOP_COUNT).parallel().forEach(i -> {String key = "item" + ThreadLocalRandom.current().nextInt(ITEM_COUNT);//利用computeIfAbsent()方法来实例化LongAdder，然后利用LongAdder来进行线程安全计数freqs.computeIfAbsent(key, k -> new LongAdder()).increment();}));forkJoinPool.shutdown();forkJoinPool.awaitTermination(1, TimeUnit.HOURS);//因为我们的Value是LongAdder而不是Long，所以需要做一次转换才能返回return freqs.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(),e -> e.getValue().longValue()));
}

        使用 ConcurrentHashMap 的原子性方法 computeIfAbsent 来做复合逻辑操作，判断 Key 是否存在 Value，如果不存在则把 Lambda 表达式运行后的结果放入 Map 作为 Value，也就是新创建一个 LongAdder 对象，最后返回 Value。

        由于 computeIfAbsent 方法返回的 Value 是 LongAdder，是一个线程安全的累加器，因此可以直接调用其 increment 方法进行累加。

4、没有认清并发工具的使用场景，因而导致性能问题

        在 Java 中，CopyOnWriteArrayList 虽然是一个线程安全的 ArrayList，但因为其实现方式是，每次修改数据时都会复制一份数据出来，所以有明显的适用场景，即读多写少或者说希望无锁读的场景。

 处理方案：

        一定要认真阅读官方文档（比如 Oracle JDK 文档）。充分阅读官方文档，理解工具的适用场景及其 API 的用法，并做一些小实验。了解之后再去使用，就可以避免大部分坑。

        如果你的代码运行在多线程环境下，那么就会有并发问题，并发问题不那么容易重现，可能需要使用压力测试模拟并发场景，来发现其中的 Bug 或性能问题。

五、代码加锁问题

场景：在一个类里有两个 int 类型的字段 a 和 b，有一个 add 方法循环 1 万次对 a 和 b 进行 ++ 操作，有另一个 compare 方法，同样循环 1 万次判断 a 是否小于 b，条件成立就打印 a 和 b 的值，并判断 a>b 是否成立。

@Slf4j
public class Interesting {volatile int a = 1;volatile int b = 1;public void add() {log.info("add start");for (int i = 0; i < 10000; i++) {a++;b++;}log.info("add done");}public void compare() {log.info("compare start");for (int i = 0; i < 10000; i++) {//a始终等于b吗？if (a < b) {log.info("a:{},b:{},{}", a, b, a > b);//最后的a>b应该始终是false吗？}}log.info("compare done");}
}

起了两个线程来分别执行 add 和 compare 方法：

Interesting interesting = new Interesting();
new Thread(() -> interesting.add()).start();
new Thread(() -> interesting.compare()).start();

        按道理，a 和 b 同样进行累加操作，应该始终相等，compare 中的第一次判断应该始终不会成立，不会输出任何日志。但，执行代码后发现不但输出了日志，而且更诡异的是，compare 方法在判断 ab 也成立：

原因：之所以出现这种错乱，是因为两个线程是交错执行 add 和 compare 方法中的业务逻辑，而且这些业务逻辑不是原子性的：a++ 和 b++ 操作中可以穿插在 compare 方法的比较代码中；更需要注意的是，a<b 这种比较操作在字节码层面是加载 a、加载 b 和比较三步，代码虽然是一行但也不是原子性的。

解决方案：为 add 和 compare 都加上方法锁，确保 add 方法执行时，compare 无法读取 a 和 b：

public synchronized void add()
public synchronized void compare()

        使用锁解决问题之前一定要理清楚，我们要保护的是什么逻辑，多线程执行的情况又是怎样的。

1、加锁前要清楚锁和被保护的对象是不是一个层面的

        静态字段属于类，类级别的锁才能保护；而非静态字段属于类实例，实例级别的锁就可以保护。

错误示例：

class Data {@Getterprivate static int counter = 0;public static int reset() {counter = 0;return counter;}public synchronized void wrong() {counter++;}
}

写一段代码测试下：

@GetMapping("wrong")
public int wrong(@RequestParam(value = "count", defaultValue = "1000000") int count) {Data.reset();//多线程循环一定次数调用Data类不同实例的wrong方法IntStream.rangeClosed(1, count).parallel().forEach(i -> new Data().wrong());return Data.getCounter();
}

        因为默认运行 100 万次，所以执行后应该输出 100 万，但页面输出的是 639242

原因：在非静态的 wrong 方法上加锁，只能确保多个线程无法执行同一个实例的 wrong 方法，却不能保证不会执行不同实例的 wrong 方法。而静态的 counter 在多个实例中共享，所以必然会出现线程安全问题。

解决方案：同样在类中定义一个 Object 类型的静态字段，在操作 counter 之前对这个字段加锁。

class Data {@Getterprivate static int counter = 0;private static Object locker = new Object();public void right() {synchronized (locker) {counter++;}}
}

2、加锁要考虑锁的粒度和场景问题

滥用 synchronized 的问题：

     ①  一是，没必要。通常情况下 60% 的业务代码是三层架构，数据经过无状态的 Controller、Service、Repository 流转到数据库，没必要使用 synchronized 来保护什么数据。

      ② 二是，可能会极大地降低性能。使用 Spring 框架时，默认情况下 Controller、Service、Repository 是单例的，加上 synchronized 会导致整个程序几乎就只能支持单线程，造成极大的性能问题。                 

        即使我们确实有一些共享资源需要保护，也要尽可能降低锁的粒度，仅对必要的代码块甚至是需要保护的资源本身加锁。

场景： 在业务代码中，有一个 ArrayList 因为会被多个线程操作而需要保护，又有一段比较耗时的操作（代码中的 slow 方法）不涉及线程安全问题

错误的做法是，给整段业务逻辑加锁，把 slow 方法和操作 ArrayList 的代码同时纳入 synchronized 代码块

正确的做法，把加锁的粒度降到最低，只在操作 ArrayList 的时候给这个 ArrayList 加锁。

private List<Integer> data = new ArrayList<>();//不涉及共享资源的慢方法
private void slow() {try {TimeUnit.MILLISECONDS.sleep(10);} catch (InterruptedException e) {}
}//错误的加锁方法
@GetMapping("wrong")
public int wrong() {long begin = System.currentTimeMillis();IntStream.rangeClosed(1, 1000).parallel().forEach(i -> {//加锁粒度太粗了synchronized (this) {slow();data.add(i);}});log.info("took:{}", System.currentTimeMillis() - begin);return data.size();
}//正确的加锁方法
@GetMapping("right")
public int right() {long begin = System.currentTimeMillis();IntStream.rangeClosed(1, 1000).parallel().forEach(i -> {slow();//只对List加锁synchronized (data) {data.add(i);}});log.info("took:{}", System.currentTimeMillis() - begin);return data.size();
}

        如果精细化考虑了锁应用范围后，性能还无法满足需求的话，我们就要考虑另一个维度的粒度问题了，即：区分读写场景以及资源的访问冲突，考虑使用悲观方式的锁还是乐观方式的锁。

        ① 对于读写比例差异明显的场景，考虑使用 ReentrantReadWriteLock 细化区分读写锁，来提高性能。

        ② 如果你的 JDK 版本高于 1.8、共享资源的冲突概率也没那么大的话，考虑使用 StampedLock 的乐观读的特性，进一步提高性能。

        ③ JDK 里 ReentrantLock 和 ReentrantReadWriteLock 都提供了公平锁的版本，在没有明确需求的情况下不要轻易开启公平锁特性，在任务很轻的情况下开启公平锁可能会让性能下降上百倍。

3、多把锁要小心死锁问题

场景：

        之前我遇到过这样一个案例：下单操作需要锁定订单中多个商品的库存，拿到所有商品的锁之后进行下单扣减库存操作，全部操作完成之后释放所有的锁。代码上线后发现，下单失败概率很高，失败后需要用户重新下单，极大影响了用户体验，还影响到了销量。

        经排查发现是死锁引起的问题，背后原因是扣减库存的顺序不同，导致并发的情况下多个线程可能相互持有部分商品的锁，又等待其他线程释放另一部分商品的锁，于是出现了死锁问题。

        首先，定义一个商品类型，包含商品名、库存剩余和商品的库存锁三个属性，每一种商品默认库存 1000 个；然后，初始化 10 个这样的商品对象来模拟商品清单：

@Data
@RequiredArgsConstructor
static class Item {final String name; //商品名int remaining = 1000; //库存剩余@ToString.Exclude //ToString不包含这个字段 ReentrantLock lock = new ReentrantLock();
}

        随后，写一个方法模拟在购物车进行商品选购，每次从商品清单（items 字段）中随机选购三个商品（为了逻辑简单，我们不考虑每次选购多个同类商品的逻辑，购物车中不体现商品数量）：

private List<Item> createCart() {return IntStream.rangeClosed(1, 3).mapToObj(i -> "item" + ThreadLocalRandom.current().nextInt(items.size())).map(name -> items.get(name)).collect(Collectors.toList());
}

        下单代码如下：先声明一个 List 来保存所有获得的锁，然后遍历购物车中的商品依次尝试获得商品的锁，最长等待 10 秒，获得全部锁之后再扣减库存；如果有无法获得锁的情况则解锁之前获得的所有锁，返回 false 下单失败。

private boolean createOrder(List<Item> order) {//存放所有获得的锁List<ReentrantLock> locks = new ArrayList<>();for (Item item : order) {try {//获得锁10秒超时if (item.lock.tryLock(10, TimeUnit.SECONDS)) {locks.add(item.lock);} else {locks.forEach(ReentrantLock::unlock);return false;}} catch (InterruptedException e) {}}//锁全部拿到之后执行扣减库存业务逻辑try {order.forEach(item -> item.remaining--);} finally {locks.forEach(ReentrantLock::unlock);}return true;
}

        模拟在多线程情况下进行 100 次创建购物车和下单操作，最后通过日志输出成功的下单次数、总剩余的商品个数、100 次下单耗时，以及下单完成后的商品库存明细：

@GetMapping("wrong")
public long wrong() {long begin = System.currentTimeMillis();//并发进行100次下单操作，统计成功次数long success = IntStream.rangeClosed(1, 100).parallel().mapToObj(i -> {List<Item> cart = createCart();return createOrder(cart);}).filter(result -> result).count();log.info("success:{} totalRemaining:{} took:{}ms items:{}",success,items.entrySet().stream().map(item -> item.getValue().remaining).reduce(0, Integer::sum),System.currentTimeMillis() - begin, items);return success;
}

        100 次下单操作成功了 65 次，10 种商品总计 10000 件，库存总计为 9805，消耗了 195 件符合预期（65 次下单成功，每次下单包含三件商品），总耗时 50 秒。

原因：

        使用 JDK 自带的 VisualVM 工具来跟踪一下，重新执行方法后不久就可以看到，线程 Tab 中提示了死锁问题，根据提示点击右侧线程 Dump 按钮进行线程抓取操作：

 查看抓取出的线程栈，在页面中部可以看到如下日志：

         是出现了死锁，线程 4 在等待的一个锁被线程 3 持有，线程 3 在等待的另一把锁被线程 4 持有。

死锁问题原因：

        个线程先获取到了 item1 的锁，同时另一个线程获取到了 item2 的锁，然后两个线程接下来要分别获取 item2 和 item1 的锁，这个时候锁已经被对方获取了，只能相互等待一直到 10 秒超时

解决方案：        

        为购物车中的商品排一下序，让所有的线程一定是先获取 item1 的锁然后获取 item2 的锁，就不会有问题了

@GetMapping("right")
public long right() {...
.    long success = IntStream.rangeClosed(1, 100).parallel().mapToObj(i -> {List<Item> cart = createCart().stream().sorted(Comparator.comparing(Item::getName)).collect(Collectors.toList());return createOrder(cart);}).filter(result -> result).count();...return success;
}