日常工作中很容易犯的几个并发错误-工作中容易犯哪些错误

前言

列举大家平时在工作中很容易犯的几个并发错误，都是在实际项目代码中看到的鲜活例子，希望对大家有帮助。

First Blood

线上总是出现：ERROR 1062 (23000) Duplicate entry 'xxx' for key 'yyy'，我们来看一下有问题的这段代码：

UserBindInfo info = selectFromDB(userId); 
if(info == null){ 
    info = new UserBindInfo(userId,deviceId); 
    insertIntoDB(info); 
}else{ 
    info.setDeviceId(deviceId); 
    updateDB(info); 
    }

在并发情况下，第一步判断都为空，就会有2个或者多个线程进入插入数据库操作，这时候就出现了同一个ID插入多次。

正确处理姿势：

insert into UserBindInfo values(#{userId},#{deviceId}) on duplicate key update deviceId=#{deviceId}多次的情况，导致插入失败。

一般情况下，可以用insert...on duplicate key update... 解决这个问题。

注意: 如果UserBindInfo表存在主键以及一个以上的唯一索引，在并发情况下，使用insert...on duplicate key，可能会产生死锁(Mysql5.7)，可以这样处理：

try{ 
   UserBindInfoMapper.insertIntoDB(userBindInfo); 
}catch(DuplicateKeyException ex){ 
    UserBindInfoMapper.update(userBindInfo); 
}

Double Kill

小心你的全局变量,如下面这段代码：

 public class GlobalVariableConcurrentTest { 
   
      private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
  
      public static void main(String[] args) throws InterruptedException { 
         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 100, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<>(1000)); 
  
         while (true){ 
             threadPoolExecutor.execute(()->{ 
                String dateString = sdf.format(new Date()); 
                 try { 
                     Date parseDate = sdf.parse(dateString); 
                    String dateString2 = sdf.format(parseDate); 
                     System.out.println(dateString.equals(dateString2)); 
                 } catch (ParseException e) { 
                     e.printStackTrace(); 
                } 
             }); 
        } 
  
     } 
  
}

可以看到有异常抛出

全局变量的SimpleDateFormat，在并发情况下，存在安全性问题，阿里Java规约明确要求谨慎使用它。

除了SimpleDateFormat，其实很多时候，面对全局变量，我们都需要考虑并发情况是否存在问题，如下

  @Component 
  public class Test { 
  
     public static List<String> desc = new ArrayList<>(); 
   
      public List<String> getDescByUserType(int userType) { 
          if (userType == 1) { 
              desc.add("普通会员不可以发送和查看邮件，请购买会员"); 
              return desc; 
         } else if (userType == 2) { 
             desc.add("恭喜你已经是VIP会员，尽情的发邮件吧"); 
            return desc; 
         }else { 
             desc.add("你的身份未知"); 
             return desc; 
         } 
     } 
 }

因为desc是全局变量，在并发情况下，请求getDescByUserType方法，得到的可能并不是你想要的结果。

Trible Kill

假设现在有如下业务：控制同一个用户访问某个接口的频率不能小于5秒。一般很容易想到使用redis的 setnx操作来控制并发访问，于是有以下代码：

 if(RedisOperation.setnx(userId, 1)){ 
     RedisOperation.expire(userId,5,TimeUnit.SECONDS)); 
      //执行正常业务逻辑 
 }else{ 
      return “访问过于频繁”; 
 }

假设执行完setnx操作，还没来得及设置expireTime，机器重启或者突然崩溃，将会发生死锁。该用户id，后面执行setnx永远将为false，这可能让你永远损失那个用户。

那么怎么解决这个问题呢，可以考虑用SET key value NX EX max-lock-time ，它是一种在 Redis 中实现锁的方法，是原子性操作，不会像以上代码分两步执行，先set再expire，它是一步到位。

客户端执行以上的命令：

如果服务器返回 OK ，那么这个客户端获得锁。
如果服务器返回 NIL ，那么客户端获取锁失败，可以在稍后再重试。
设置的过期时间到达之后，锁将自动释放

Quadra Kill

我们看一下有关ConcurrentHashMap的一段代码，如下：

  //全局变量 
  Map<String, Integer> map = new ConcurrentHashMap();  
  
 Integer value = count.get(k); 
 if(value == null){ 
         map.put(k,1); 
  }else{ 
      map.put(k,value+1); 
  }

假设两条线程都进入 value==null，这一步，得出的结果是不是会变小?OK,客官先稍作休息，闭目养神一会，我们验证一下，请看一个demo：

  public static void main(String[] args)  { 
          for (int i = 0; i < 1000; i++) { 
              testConcurrentMap(); 
          } 
      } 
      private static void testConcurrentMap() { 
          final Map<String, Integer> count = new ConcurrentHashMap<>(); 
          ExecutorService executorService = Executors.newFixedThreadPool(2); 
         final CountDownLatch endLatch = new CountDownLatch(2); 
         Runnable task = ()->  { 
                 for (int i = 0; i < 5; i++) { 
                     Integer value = count.get("k"); 
                     if (null == value) { 
                         System.out.println(Thread.currentThread().getName()); 
                         count.put("k", 1); 
                     } else { 
                         count.put("k", value + 1); 
                     } 
                 } 
                 endLatch.countDown(); 
         }; 
  
         executorService.execute(task); 
         executorService.execute(task); 
 
        try { 
             endLatch.await(); 
             if (count.get("k") < 10) { 
                 System.out.println(count); 
             } 
        } catch (Exception e) { 
            e.printStackTrace(); 
        }

表面看，运行结果应该都是10对吧，好的，我们再看运行结果：

运行结果出现了5，所以这样实现是有并发问题的，那么正确的实现姿势是啥呢?

  Map<K,V> map = new ConcurrentHashMap();  
  V v = map.get(k); 
  if(v == null){ 
          V v = new V(); 
          V old = map. putIfAbsent(k,v); 
          if(old != null){ 
                   v = old; 
          } 
  }

可以考虑使用putIfAbsent解决这个问题

(1)如果key是新的记录，那么会向map中添加该键值对，并返回null。

(2)如果key已经存在，那么不会覆盖已有的值，返回已经存在的值

我们再来看看以下代码以及运行结果：

  public static void main(String[] args)  { 
          for (int i = 0; i < 1000; i++) { 
              testConcurrentMap(); 
          } 
      } 
   
      private static void testConcurrentMap() { 
          ExecutorService executorService = Executors.newFixedThreadPool(2); 
          final Map<String, AtomicInteger> map = Maps.newConcurrentMap(); 
         final CountDownLatch countDownLatch = new CountDownLatch(2); 
  
         Runnable task = ()->  { 
                 AtomicInteger oldValue; 
                 for (int i = 0; i < 5; i++) { 
                     oldValue = map.get("k"); 
                    if (null == oldValue) { 
                         AtomicInteger initValue = new AtomicInteger(0); 
                         oldValue = map.putIfAbsent("k", initValue); 
                         if (oldValue == null) { 
                             oldValue = initValue; 
                         } 
                     } 
                     oldValue.incrementAndGet(); 
                 } 
             countDownLatch.countDown(); 
         }; 
  
         executorService.execute(task); 
         executorService.execute(task); 
  
         try { 
             countDownLatch.await(); 
             System.out.println(map); 
         } catch (Exception e) { 
             e.printStackTrace(); 
         } 
    }

Penta Kill

现有如下业务场景：用户手上有一张现金券，可以兑换相应的现金，

错误示范一

if(isAvailable(ticketId){ 
    1、给现金增加操作 
    2、deleteTicketById(ticketId) 
}else{ 
    return “没有可用现金券” 
}

解析：假设有两条线程A,B兑换现金，执行顺序如下：

1.线程A加现金

2.线程B加现金

3.线程A删除票标志

4.线程B删除票标志

显然，这样有问题了，已经给用户加了两次现金了。

错误示范2

  if(isAvailable(ticketId){ 
      1、deleteTicketById(ticketId) 
      2、给现金增加操作 
  }else{ 
     return “没有可用现金券” 
  }

并发情况下，如果一条线程，第一步deleteTicketById删除失败了，也会多添加现金。

正确处理方案

  if(deleteAvailableTicketById(ticketId) == 1){ 
      1、给现金增加操作 
  }else{ 
      return “没有可用现金券” 
  }