模拟多线程并发订单处理功能实现

该文为整理合并其他博主文章！已经注释相关部分原文链接，如有疑问私信可删！感谢分享！

原文地址：https://blog.csdn.net/gfdgdshhg/article/details/79052517

在目前的应用开发中，有一个需要自动处理某状态订单的功能，需要和手动处理功能并行不能冲突和重复处理。目前大致写了一下demo实现，记录一下，方便以后有时间复习和改进。实现思路也比较简单，就是处理每笔订单的时候加个锁，无论是手动还是自动，都需要取得订单锁后才能处理，待处理订单队列方面，因为要考虑并发动态的添加或移除订单元素，暂时采用CopyOnWriteArrayList（ConcurrentHashMap也可以）来实现。加锁和解锁的过程都加了令牌，一来方便测试时验证加锁和解锁的是否为同一线程；二来也可以避免工程中误调解锁功能而导致程序出错。感觉对线程这块的知识掌握的还是不够深入，以后要多多加强。代码如下：

import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CyclicBarrier;

public class ThreadTest {
    //需要处理的订单数量,
    private static int MAX_ORDERS=10000;
    //最大线程数
    private  static  int MAX_THREADS =100;
    //每个线程睡眠时间(订单处理时间)
    private static  int SLEEP =10;
    //写复制list,支持并发修改和遍历功能,需要注意内存耗费的问题，可以采用ConcurrentHashMap等代替
    private static  List<Order> list=new CopyOnWriteArrayList<>();//new CopyOnWriteArrayList<>();//new ArrayList<>();
    static {//初始化测试数据
        for(int i=0;i<MAX_ORDERS;i++)
            list.add(new Order("HHHH"+i));
    }
    public  static  void main(String ss[]){
        /**
         * 记录开始时间，理论上耗时略大于MAX_ORDERS×SLEEP/MAX_THREADS
         */
        Long t=System.currentTimeMillis();
        //同步屏障,以是住线程能等待所有线程结束，并记录下耗时
        final CyclicBarrier cyclicBarrier=new CyclicBarrier(MAX_THREADS+1);
        for(int i = 0; i< MAX_THREADS; i++){//创建并启动订单处理线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                        while (!list.isEmpty()) {
                            Order order = null;
                            //生成唯一加锁令牌，保证唯一性即可
                            String uuid = UUID.randomUUID().toString();
                            int i = 0;//记录查找到未处理的订单位置
                            for (Order item : list) {
                                i++;
                                if (item.getLock(uuid)) {//找到并锁定订单
                                    order = item;
                                    break;
                                }
                            }
                            if (order != null) {//获取到可处理的订单
                                System.out.println(i + ":" + Thread.currentThread().getId() + "(" + SLEEP + ")正在处理订单：" + order.getApplyNo());
                                try {
                                    Thread.sleep(SLEEP);//模拟订单处理功能
                                    list.remove(order);//处理成功后将订单重待处理列表中移除
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }finally {
                                    /**
                                     * 无论成功还是失败，都需要解锁订单
                                     * 失败情况下订单依旧留在待处理列表中,供其他线程处理
                                     * 可以根据实际情况将处理失败的订单转移到别的地方进行处理
                                     * 否则会导致坏订单影响后面正常订单的处理
                                     */
                                    order.unLock(uuid);//解锁订单
                                }

                            }

                        }
                        try {
                            cyclicBarrier.await();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }

                    }

            }).start();
        }
        try{
            //等待所有线程执行完成
            cyclicBarrier.await();
        }catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("*******订单处理完成，耗时："+(System.currentTimeMillis()-t)+"ms");

    }

    static  class  Order{
        private String applyNo;

        public  Order(String applyNo){
            this.applyNo=applyNo;
        }
        public String getApplyNo() {
            return applyNo;
        }
        private    boolean  lock=true;
        //用来检验加锁和解锁的是否为同一线程
        private  String token="";

        /**
         * 加锁，先判断是否已被锁住，未被锁住则获取该对象锁
         * @param token
         * @return
         */
        public boolean getLock(String token){
            if(lock){
                synchronized (this){
                    if(lock){//双重检测
                        lock=false;
                        this.token=token;
                        return true;
                    }else{
                        System.out.println("被别人抢走了！！！！！！！！！！");
                    }

                }

            }
            return lock;
        }

        /**
         * 解锁,通过token限定只有获取到锁的线程才能解锁,否则为非法调用
         * @param newToken
         */
        public void unLock(String newToken){
            if(!newToken.equals(this.token)||lock){
                System.out.println("出错了！！！！！！！！！！");
            }else{
                lock=true;
            }
        }

    }
}

 

我用的是hibernate框架，所以在处理订单的时候发生异常！

HibernateException: Illegal attempt to associate a collection with two open sessions...

我的实体类里面关联了其他表，采用了懒加载方式，在此更新订单信息的时候调用封装的service.saveOrUpdate(entity),抛出该异常！

将   session.save (entity);

方法改成 session.merge(entity);

merge 方法是合并为一个session。

附件 ：

Hibernate Session 4种对象状态

Hibernate update 和 merge 、saveOrUpdate的区别