绑定完请刷新页面
取消
刷新

分享好友

×
取消 复制
日常工作中最容易犯的几个并发错误
2019-12-25 14:49:31

前言

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


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 = 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 “没有可用现金券”
}



作者:Jay_huaxiao

链接:https://juejin.im/post/5dfec2806fb9a016043a59a6

来源:掘金

著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。


分享好友

分享这个小栈给你的朋友们,一起进步吧。

Java小专栏
创建时间:2019-08-08 21:32:06
Java专栏专注技术分享
展开
订阅须知

• 所有用户可根据关注领域订阅专区或所有专区

• 付费订阅:虚拟交易,一经交易不退款;若特殊情况,可3日内客服咨询

• 专区发布评论属默认订阅所评论专区(除付费小栈外)

栈主、嘉宾

查看更多
  • lihong
    栈主

小栈成员

查看更多
  • 栈栈
  • 杨三百
  • at_1
  • gaokeke123
戳我,来吐槽~