[practice-mistake] 并发工具类库

[Alice52]

1. Juc

1. ThreadLocal | InheritableTL(继承-但看不见修改) | TransmitableTL(继承且看见修改): 线程池中使用之后没有 remove, 导致用户信息错乱, 且会导致内存泄漏
2. ConcurrentHashMap 只保证提供原子性的读写操作是线程安全的
   • containsKey/size/isEmpty/containsValue/putAll 等都有可能获取中间态数据, 不能作为流程控制
   • sample: 统计大文本每个key出现的次数{CHM+LongAdder+putInAbsent+多线程}
3. CopyOnWriteArrayList 在大量写的情况下会有性能问题
   • 修改时会先复制出来一份
4. Map 方法
   • putIfAbsent: HashMap 可以KV 为null, CHM 不可以为null会直接报错
   • computeIfAbsent: Functional 为null 则不会真正的put 进去

[Alice52]

2. Lock

1. 8 lock
   • 静态字段问题
   • 同步方法与非同步方法
2. 锁的粒度和场景问题
   • 尽量小的锁粒度{范围} + 区分读写场景/资源访问冲突
   • 读多写少的 ReentrantReadWriteLock: 共享度互斥写, 读写冲突{悲观的读锁}
   • 冲突概率不大可以使用 StampedLock: 也是读写锁, 乐观的读锁
   • 没有明确的需求不要开启公平锁: 效率很低{尤其在任务很轻时}
3. 死锁
   • 减小锁粒度就会带有不同的粒度锁, 锁多了就有可能带来死锁问题
   • sample: 多用户并发下单多个商品, 可能出现死锁{对商品排序之后获取锁}
   • 一般性方案: 避免无限等待和循环等待
   • 锁是否配对及对应的释放
   • 超时自动释放, 耗时逻辑时的锁自动续期, 重复执行等

[Alice52]

3. 线程池

1. 使用 Executors 创建线程池会有问题: OOM
2. 线程池可以在一个项目中根据不同的场景创建多个, 避免混用: 每个线程池中线程数量都不应该太大[1~100] cpu核心数相关
3. ForkJoinPool 的默认并发数是 CPU-1, 适合Cpu密集型; 如果是IO密集型建议新建一个pool
4. tips
   • threadPool.allowCoreThreadTimeOut(true): core size 可以被回收
   • threadPool.prestartAllCoreThreads(): 优先初始化core size
5. 线程池应该尽量有相关的监控
6. 使用激进的线程创建, 改变之前的先入queue之后才开辟到max-pool-size
   • offer: response false
   • reject 中put queue

   public void execute(Runnable command) {
       if (command == null)
           throw new NullPointerException();
   
       int c = ctl.get();
       // 当前线程总数小于 core-pool-size 则创建线程执行
       if (workerCountOf(c) < corePoolSize) {
           if (addWorker(command, true))
               return;
           c = ctl.get();
       }
       // core-pool-size 最大则入 queue
       if (isRunning(c) && workQueue.offer(command)) {
           int recheck = ctl.get();
           if (! isRunning(recheck) && remove(command))
               reject(command);
           else if (workerCountOf(recheck) == 0)
               addWorker(null, false);
       }
       // 如果入 queue 失败或者使用 SynchronousQueue 则执行 reject
       else if (!addWorker(command, false))
           reject(command);
   }
   
   BlockingQueue<Runnable> queue =
           new LinkedBlockingQueue<Runnable>(10) {
               @Override
               public boolean offer(Runnable e) {
                   // 先返回false，造成队列满的假象，让线程池优先扩容
                   return false;
               }
           };
   RejectedExecutionHandler handler =
           (r, executor) -> {
               try {
                   // 等出现拒绝后再加入队列,
                   // 如果希望队列满了阻塞线程而不是抛出异常，那么可以注释掉下面三行代码，修改为 executor.getQueue().put(r);
                   if (!executor.getQueue().offer(r, 0, TimeUnit.SECONDS)) {
                       throw new RejectedExecutionException(
                               "ThreadPool queue full, failed to offer " + r.toString());
                   }
               } catch (InterruptedException e) {
                   Thread.currentThread().interrupt();
               }
           };

[Alice52]

4. 连接池

1. 作用
   

2. 常见的连接池

   • mysql连接池
   • redis连接池
   • http连接池

3. 创建的3种实现池化: 一般约束

   • 连接池和链接分离的api: JedisPool
     1. 有 XxxPool[线程安全] 类负责连接池实现: XxxConnection[非线程安全]
     2. 使用端先获取连接, 使用, 归还给连接池: 对XxxPool内资源操作可以并发
   • 内部带有连接池的 api: RedisTemplate/CloseableHttpClient/@Transactional
     1. 有 XxxClient 使用: 内部维护线程池[使用时无需考虑获取与归还问题]
     2. XxxClient 一般会是线程安全的
   • 非连接池的api
     1. 有XxxConnection, 每次使用都需要创建和断开连接
     2. 所以性能很一般, 且一般都是线程不安全的

4. jedis: 一定要使用池化的, 否则使用一个 Connection 在并发下会导致很多问题{stream closed, socket closed, value unexpected}

   • connection 的实现本身就是非线程安全的
   • 使用线程池让每个线程都是用各自的 connection: jedis pool 维护另一个线程池{+stateStore}
     

5. 连接池使用

   • 确保连接池复用, 且实现线程安全
   • 尽量确保程序退出显示关闭连接池释放资源
   • 最大连接数非常重要

6. 超时

   // 假设我们希望设置 连接超时5s. 获取连接超时10s
   
   // 1. hikari两个参数设置方式
   spring.datasource.hikari.connection-timeout=10000
   spring.datasource.url=jdbc:mysql://localhost:6657/common_mistakes?connectTimeout=5000&characterEncoding=UTF-8&useSSL=false&rewriteBatchedStatements=true
   
   // 2. jedis两个参数设置
   JedisPoolConfig config = new JedisPoolConfig();
           config.setMaxWaitMillis(10000);
           try (JedisPool jedisPool = new JedisPool(config, "127.0.0.1", 6379, 5000);
                Jedis jedis = jedisPool.getResource()) {
               return jedis.set("test", "test");
           }
   
   // 3. httpclient两个参数设置
   RequestConfig requestConfig = RequestConfig.custom()
                   .setConnectTimeout(5000)
                   .setConnectionRequestTimeout(10000)
                   .build();

[Alice52]

• openfeign-mis-use
• feign-hystrix-concurrent
• hystrix-config

5. Http 超时/重试/并发

• 一般性认为连接超时是网络问题或者服务不在线; 读取超时是服务处理超时

1. 连接超时: ConnectTimeout, 建立连接的最长等待时间 [1-5s]

   • 误区1: 【错误】设置很长时间, tcp 三次握手建立连接需要的时间是很短的, 连接不上的话配置很长时间就是浪费
   • 误区2: 【事实】排查超时时, 需要注意上下游, 比如 nginx

2. 读取超时: ReadTimeout, 从 socket 上读取数据的最长等待时间 [1~30s]

   • 误区1: 【事实】读取超时, 服务端的执行是不会终止的
   • 误区2: 【错误】将 readtimeout 设置的很小[认为只是 socket网络层的]; 事实是发生读取超时时, 网络层面无法区分是服务端没有把数据返回给客户端, 还是数据在网络上耗时或丢包
   • 误区3: 【错误】认为任务超时时间越长成功率就越高, 所以讲超时配的很大
     1. http 请求是需要结果的, 属于同步调用: 异步任务定时任务可以超时配置大一些
     2. 如果超时很大, 当很多超时时会被大量的线程拖垮

3. feign & robbin 超时

   • feign 默认读取超时是 1s: 很坑

     # 修改 feign 自身的默认超时
     feign.client.config.default.readTimeout=3_000
     feign.client.config.default.connectTimeout=3_000
     # 配置指定的 FeignClient 的超时时间
     feign.client.config.CLIENGT_NAME.connectTimeout=3_000
     # 注意！！！: 这里如果只配置 readTimeout 是不会生效的, 必须同时配置: 新版本中已修复

   • ribbon 的超时

     # 修改 ribbon 自身的默认超时
     ribbon.ReadTimeout=4_000
     ribbon.ConnectTimeout=4_000

   • feign & robbin 两个都有配置以 feign 为准
   • robbin Get请求会默认重试一次, POST 不会: 可以通过 MaxAutoRetrieNextServer=0 配置

4. 并发数: 前期http1.0时有些实现框架对每个域名限制2个并发 defaultMaxPerRoute

5. 写入超时

   • 客户端发送数据到服务端, 首先接力连接[TCP], 然后写入TCP缓冲区
   • TCP缓冲区根据时间窗口, 发送数据到服务端
   • 因此写入操作可以任务是自己本地的操作，本地操作是不需要什么超时时间的
   • 其实也就是到socket sendbuffer的超时: 满的话等待空间释放的超时

[Alice52]

• string#intern

6. Spring Transaction

1. 事务没生效
   • 除非特殊配置[比如使用 AspectJ 静态织入实现 AOP], 否则只有定义在 public 方法上的 @Transactional 才能生效
   • 必须通过代理过的类从外部调用目标方法才能生效
   • Spring Transaction 的实现有 jdk 和 cglib 两种{实现类上使用, spring 默认切换}
2. 异常回滚失效
   • 只有异常传播出标记了 @Transactional 注解的方法, 事务才能回滚
   • 默认情况下, 出现 RuntimeException[非受检异常] 或 Error 的时候, Spring 才会回滚事务
3. 事务没提交
   • 子方法内需要父方法的数据, 可以考虑传值或者 @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMI) [事件]; 而不是去修改事务的隔离级别
   • 注册一个用户, 附带着会创建一个子用户[目标是单独单独的事务{不影响主用户的流程}]
   • 正确的实现方式是: propagation = Propagation.REQUIRES_NEW
   • 无法提交: 但是当使用默认传播级别, 且字用户创建使用 try...catch 时, 且子用户中throw异常, 则主用户事务是无法提交的{在同一个事务中, 子用户创建异常会标记事务rollback}

   @Transactional
   public void createUserWrong2(UserEntity entity) {
      createMainUser(entity);
      try{
          subUserService.createSubUserWithExceptionWrong(entity);
      } catch (Exception ex) {
          // 虽然捕获了异常，但是因为没有开启新事务，而当前事务因为异常已经被标记为rollback了，所以最终还是会回滚。
          log.error("create sub user error:{}", ex.getMessage());
      }
   }
   
   private void createMainUser(UserEntity entity) {
      userRepository.save(entity);
      log.info("createMainUser finish");
   }
   
   @Transactional
   public void subUserService#createSubUserWithExceptionWrong(UserEntity entity) {
      log.info("createSubUserWithExceptionWrong start");
      userRepository.save(entity);
      throw new RuntimeException("invalid status");
   }

[Alice52]

8.equals

1. equals 方法的重写
   • 考虑到性能: 可以先进行指针判等, 如果对象是同一个那么直接返回 true
   • 需要对另一方进行判空: 空对象和自身进行比较, 结果一定是 fasle
   • 需要判断两个对象的类型: 如果类型都不同，那么直接返回 false
   • 确保类型相同的情况下再进行类型强制转换, 然后逐一判断所有字段
2. lombok 对象继承时 @EqualsAndHashCode 默认是不会使用父类属性的
   • @EqualsAndHashCode(callSuper = true)
3. equals & hashcode & compareTo 需要具有一致性
   • HashMap
4. enum 中所有类型都尽量使用非引用类型
5. equals比较的对象除了所谓的相等外, 还有一个非常重要的因素, 就是该对象的类加载器也必须是同一个

[Alice52]

9. 数值计算

1. 浮点型精度计算需要使用 BigDecimal
2. 使用 BigDecimal 表示和计算浮点数, 且务必使用字符串的构造方法来初始化 BigDecimal
3. 如果一定要用 Double 来初始化 BigDecimal 的话, 可以使用 BigDecimal.valueOf 方法
4. 浮点数的字符串格式化也要通过 BigDecimal 进行
5. BigDecimal 的 equals 比较精度和值, 如果我们希望只比较 BigDecimal 的 value, 可以使用 compareTo 方法
6. BigDecimal 与Hash一起使用
   • HashSet/HashMap 都是使用 equals & hashcode 进行操作的, 所以会出问题**[精度]**
   • HashMap + stripTrailingZeros 使用
   • || 使用 TreeMap: 底层使用的是 compareTo
7. 数字的溢出
   • 显然这是发生了溢出, 而且是默默的溢出, 并没有任何异常
   • 使用 Math 类的 addExact、subtractExact, xxExact 可以在溢出是异常
   • 使用 BigInteger, 但是当转换为基本类型还是可能会报溢出异常

[Alice52]

• 多线程并发
• jvm
• annotation
• spi

10. List

1. RandomAccess & Deque

   

2. Arrays

   • 不能直接使用 Arrays.asList 来转换基本类型数组
   • Arrays.asList 返回的 List 不支持增删操作: 但是可以修改
   • 对原始数组的修改会影响到我们获得的那个 List

3. List

   • subList 会导致被切割对象无法被回收, 可能导致oom
   • SubList 本身没有存储元素, 是 ArrayList 的视图
   • 修改值会彼此影响, 各自有 modCount, 但是操作时两个值必须是一样的
   • 要对大 List 进行单值搜索的话, 可以考虑使用 HashMap:
     • 其中 Key 是要搜索的值, Value 是原始对象,
     • 会比使用 ArrayList 有非常明显的性能优势
   • LinkedList 性能不太好, 可以考虑使用 ArrayDeque; 除非使用具体位置[ArrayDeque不适应]{ArrayList适应}
   • ArrayList 遍历时删除会出现 ConcurrentModificationException: 考虑使用迭代器去修改

[Alice52]

11. 空指针异常

1. 常见场景
   • 自动拆箱: 参数值是包装类型
   • 字符串比较出现空指针异常
   • 容器不支持 Key 和 Value 为 null:
     1. ConcurrentHashMap, ArrayDeque, Hashtable, TreeMap[value is nullable], BlockingQueue: null 不知是不存在还是值为null
     2. HashMap KV 都可以为null
        
   • A 对象包含了 B 使用时没有判断空
   • 方法或远程服务返回的 List 不是空而是 null: 没有进行判空就直接调用 List 的方法出现空指针异常

[Alice52]

12. 异常

1. 常见错误
   • 不在业务代码层面考虑异常处理，仅在框架层面粗犷捕获和处理异常: 全局异常处理被用作兜底
     1. 自定义异常: Warn + 异常信息[栈] + 请求信息[URL/方法/用户/参数等];
     2. 未知异常: Error + 异常信息[栈] + 请求信息[URL/方法/用户/参数等] + 普适信息
   • 捕获了异常后直接生吞
   • 丢弃异常的原始信息
   • 抛出异常时不指定任何消息
2. 异常处理
   • 日志记录
   • 转换为其他异常: 关联上之前的异常
   • 重试
   • 恢复
3. finally 中出现异常: 覆盖了之前的异常
4. 资源类一定使用: ** try-with-resources**
5. 千万别把异常定义为静态变量: 会导致堆栈信息错乱
6. 线程池中的异常问题
   • 线程异常处理的顺序: ThreadGroup 处理器 -- 线程默认的处理器 -- jdk ThreadGroup 中 print-stack 处理
   • execute 方法在出现异常时会终止线程并重新创建
     1. 大量的异常会导致线程重复创建引起性能问题
   • submit 方法在出现异常时不会终止线程, 但是会吃掉异常:
     1. 因为 FutureTask 在执行任务出现异常之后，异常存到了一个 outcome 字段中
     2. 只有在调用 get 方法获取 FutureTask 结果的时候，才会以 ExecutionException 的形式重新抛出异常

[Alice52]

14.io

1. 乱码问题: FileReader 是以当前机器的默认字符集来读取文件的
   • 应该指定字符集
2. 读取超出内存大小的大文件时会出现 OOM
   • 使用 Files 中的 stream 流不会导致 OOM
3. IO 文件句柄的释放
   • try-with-resources
4. IO性能: 注意读写文件要考虑设置缓冲区
   • 一定要设置缓冲区, 即使是使用 BufferedOutputStream

[Alice52]

15. Serialize & Enum

1. redis serialize
2. spring 中的 ObjectMapper 尽量不去覆盖之前的 Bean
   • FAIL_ON_UNKNOWN_PROPERTIES: 反序列化时忽略未知字段

   // 或者 spring.jackson.serialization.write_enums_using_index=true
   @Bean
   public Jackson2ObjectMapperBuilderCustomizer customizer(){
       return builder -> builder.featuresToEnable(SerializationFeature.WRITE_ENUMS_USING_INDEX);
   }

3. 默认情况下，在反序列化的时候，Jackson 框架只会调用无参构造方法创建对象
   • 如果走自定义的构造方法创建对象, 需要通过 @JsonCreator 来指定构造方法
   • 并通过 @JsonProperty 设置构造方法中参数对应的 JSON 属性名
4. 枚举 enum
   • 客户端和服务端的枚举定义不一致时, 会出异常
   • 枚举序列化反序列化实现自定义的字段非常麻烦，会涉及 Jackson 的 Bug
5. 使用枚举的字段交互 API
   • 设置全局的 enum 未知转默认配置: read_unknown_enum_values_using_default_value
   • 定义 enum 默认值: @JsonEnumDefaultValue UNKNOWN(-1, "未知");
   • 配置 enum 中要使用的交互字段: @JsonValue
   • 配置 restTemplate 中的 jackson converter
   • 反序列化没有使用 @JsonValue 字段: 自定义一个 EnumDeserializer, 并注册到 jackson 配置中
   • deatil code

     @Slf4j
     @Getter
     @AllArgsConstructor
     public enum StatusEnumClient {
         CREATED(1, "已创建"),
         PAID(2, "已支付"),
         DELIVERED(3, "已送到"),
         FINISHED(4, "已完成"),
         @JsonEnumDefaultValue
         UNKNOWN(-1, "未知");
     
         @JsonValue private final int status;
         private final String desc;
     }
     
      @Bean
      public Jackson2ObjectMapperBuilderCustomizer customizer() {
          return builder -> {
              builder.locale(Locale.CHINA);
              builder.timeZone(TimeZone.getTimeZone(ZoneId.systemDefault()));
              builder.simpleDateFormat(DatePattern.NORM_DATETIME_PATTERN);
              builder.featuresToEnable(SerializationFeature.WRITE_ENUMS_USING_INDEX);
              // spring.jackson.deserialization.read_unknown_enum_values_using_default_value=true
              builder.featuresToEnable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE);
     
              SimpleModule module = new SimpleModule();
              module.addDeserializer(Enum.class, new EnumDeserializer());
              builder.modules(module);
          };
      }
     
      @Bean
      public RestTemplate restTemplate(MappingJackson2HttpMessageConverter converter) {
          return new RestTemplateBuilder().additionalMessageConverters(converter).build();
      }
     
      @Slf4j
      @NoArgsConstructor
      @AllArgsConstructor
      public class EnumDeserializer extends JsonDeserializer<Enum> implements ContextualDeserializer {
          private Class<Enum> targetClass;
     
          @Override
          public Enum deserialize(JsonParser p, DeserializationContext ctxt) {
              // 找枚举中带有@JsonValue注解的字段，这个字段是我们反序列化的基准字段
              Optional<Field> valueFieldOpt = Arrays.asList(targetClass.getDeclaredFields()).stream()
                      .filter(m -> m.isAnnotationPresent(JsonValue.class)).findFirst();
     
              if (valueFieldOpt.isPresent()) {
                  Field valueField = valueFieldOpt.get();
                  if (!valueField.isAccessible()) {
                      valueField.setAccessible(true);
              }
              // 遍历枚举项，查找字段的值等于反序列化的字符串的那个枚举项
              return Arrays.stream(targetClass.getEnumConstants())
                      .filter(e -> valueField.get(e).toString().equals(p.getValueAsString()))
                      .findFirst()
                      .orElseGet(
                          () -> Arrays.stream(targetClass.getEnumConstants())
                              .filter(e -> {
                                  // 如果找不到，那么就需要寻找默认枚举值来替代，同样遍历所有枚举项，查找@JsonEnumDefaultValue注解标识的枚举项
                                  return targetClass.getField(e.name()).isAnnotationPresent(JsonEnumDefaultValue.class);
                              })
                              .findFirst().orElse(null));
             }
     
             return null;
         }
     
         @Override
         public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
             targetClass = (Class<Enum>) ctxt.getContextualType().getRawClass();
             return new EnumDeserializer(targetClass);
         }
     
     }