半同步半异步模式的实现_.NET_编程开发_程序员俱乐部

所谓半同步半异步是指，在某个方法调用中，有些代码行是同步执行方式，有些代码行是异步执行方式，下面我们来举个例子，还是以经典的PlaceOrder来说，哈哈。

PlaceOrder的主要逻辑：

public bool PlaceOrder(OrderInfo order)
{
            //验证Order合法性

            //OrderInfo增加到仓储

            //生成order的pdf            

            //通知客户，email方式
}

我们假设做出如下决定：

public bool PlaceOrder(OrderInfo order)
{
            //验证Order合法性           （同步执行）

            //OrderInfo增加到仓储       （异步执行，考虑到锁，要放到消息队列中，让后台Worker来执行具体的sql操作）

            //生成order的pdf           （同步执行，其实也可以异步，此处demo意图，因此做成同步执行）

            //通知客户，email方式        （同步执行，同上）
}

如上面所示，如果我们只是在"OrderInfo增加到仓储"这里通过Async方式（无论是多线程，或者是msmq、rabbitq），如果只是触发这个异步执行，那么到函数返回时，很可能这个异步操作还没有执行完成，但是UI层（又或者其他函数）却需要某些信息，比如OrderID。因此，在这个函数中，除了发起异步调用外，还需要wait，直到异步调用执行完成，其实这个函数相当于完成了2个线程并行执行，但是最终返回的条件必须是2个线程都执行完成。

我们来看下

        EventWaitHandle signal = new EventWaitHandle(true, EventResetMode.ManualReset);   //多线程之间的阻塞机制，需要这个变量
        OrderInfo returnedOrderInfo = null;                    //从多线程那边返回的变量会保存在这里
        public bool PlaceOrder(OrderInfo order)
        {
            //验证Order合法性           （同步执行）

            //OrderInfo增加到仓储       （异步执行，考虑到锁，要放到消息队列中，让后台Worker来执行具体的sql操作）
            string msgId=SendOrder2Queue(order);     //发送order到msmq，并且获取相应的消息ID，因为后面会用到这个消息ID

            //生成order的pdf

            //会在这里阻塞，直到应答队列出现相应msgId的消息为止
            signal.Reset();                   //初始化变量
            returnedOrderInfo = null;         //初始化变量
            ThreadPool.QueueUserWorkItem(new WaitCallback(CheckResponseQueue), msgId);     //调用ms的ThreadPool进行多线程
            signal.WaitOne();                 //阻塞住，直到子线程发出Set命令

            //通知客户，email方式

            //收尾逻辑
            if (this.returnedOrderInfo != null && !this.returnedOrderInfo.OrderID.Equals(Guid.Empty))
            {
                CloneOrder(order, this.returnedOrderInfo);
                return true;
            }
            return false;
        }

 需要注意的地方是，发送email那里，必须放在最后面，想象下这种情况：插入数据库失败了，此时msmq的应答队列就会返回相应的失败消息，此时就需要根据结果来判断，是否需要发送email了（上面代码没有考虑到这点）。

 考虑到断电等情况，需要将msmq创建为Transaction类型的queue，如下：

public static class Config
    {
        public static readonly string OrderQueueConnectionString = ".\\private$\\Order";
        public static readonly string OrderResponseQueueConnectionString = ".\\private$\\OrderResponse";
        public static void PrepareMSMQ()
        {
            if (MessageQueue.Exists(OrderQueueConnectionString))
                MessageQueue.Delete(OrderQueueConnectionString);
            if (MessageQueue.Exists(OrderResponseQueueConnectionString))
                MessageQueue.Delete(OrderResponseQueueConnectionString);

            MessageQueue.Create(OrderQueueConnectionString, true);   //true，代表Transaction的队列
            MessageQueue.Create(OrderResponseQueueConnectionString, true); //同上
        }
    }

大家已经看到了，其实有2个队列需要建立，一个是发送队列，另外一个是应答队列；ThreadPool中的子线程就是用来Monitor这个应答队列中是否有相应消息的，我们来看看代码：

private void CheckResponseQueue(object state)
        {
            string msgId = (string)state;
            string sMessageConnectionString_ResponseQueue = Config.OrderResponseQueueConnectionString;
            MessageQueue mq_response = new MessageQueue(sMessageConnectionString_ResponseQueue);
            mq_response.Formatter = new XmlMessageFormatter(new Type[] { typeof(OrderInfo) });  //这个很重要，要传输什么样的消息，就要写相应的格式化程序
            while (true)
            {
                System.Threading.Thread.Sleep(200);
                Message[] msgs = mq_response.GetAllMessages();      //这句会获取所有的消息，但是不会从队列中去掉，类似于Peek的效果
                
                string foundMsgId = string.Empty;
                foreach(Message msg in msgs)
                {
                    if (msg.Label == msgId)
                    {
                        foundMsgId = msg.Id;
                        break;
                    }
                }
                if (foundMsgId != string.Empty)
                {
                    Message msg=mq_response.ReceiveById(foundMsgId);  //找到msgId后，这句才会真正从队列中移除消息
                    OrderInfo replyOrderInfo=(OrderInfo)msg.Body;

                    returnedOrderInfo = new OrderInfo();              //赋值给返回变量
                    returnedOrderInfo.FirstName = replyOrderInfo.FirstName;
                    returnedOrderInfo.LastName = replyOrderInfo.LastName;
                    returnedOrderInfo.BuyWhat = replyOrderInfo.BuyWhat;
                    returnedOrderInfo.OrderID = replyOrderInfo.OrderID;
                    break;
                }
            }
            signal.Set();             //发出信号，代表完成，让主线程继续往下执行
        }

 下面再来看看消息发送后，真正的后台处理程序（是个Console程序）：

class Program
    {
        static void Main(string[] args)
        {
            System.Threading.Thread.Sleep(2000);
            string msmq = Core.Config.OrderQueueConnectionString;
            if (!MessageQueue.Exists(msmq))
            {
                Console.WriteLine("msmq not exist.");
                return;
            }

            MessageQueue mq = new MessageQueue(msmq);
            MessageQueueTransaction tx = new MessageQueueTransaction();                    //事务性队列必须用这个才能正确插入消息
            mq.Formatter = new XmlMessageFormatter(new Type[] { typeof(OrderInfo) });
            while (true)
            {
                Message msg = mq.Receive();
                Console.WriteLine("processing {0}", msg.Id);
                OrderInfo order = (OrderInfo)msg.Body;

                order.FirstName +=", processed on "+DateTime.Now.ToString();
                order.OrderID = Guid.NewGuid();

                if (msg.ResponseQueue != null)           //由于在发送消息的时候已经指定了应答队列，因此此处只是简单的判断这个属性就可以了
                {
                    Message msg_reply = new Message();
                    msg_reply.Body = order;
                    msg_reply.Label = msg.Id;
                    msg_reply.Formatter = new System.Messaging.XmlMessageFormatter(new Type[] { typeof(OrderInfo) });

                    tx.Begin();   //很重要
                    msg.ResponseQueue.Send(msg_reply, tx);
                    tx.Commit();  //同上
                }
                Console.WriteLine("done");
            }
        }
    }

我们再来看下主程序：

class Program
    {
        static void Main(string[] args)
        {
            Config.PrepareMSMQ();  //准备msmq资源，比如create等

            OrderInfo order = new OrderInfo();
            order.FirstName = "aaron";
            order.LastName = "dai";
            order.BuyWhat = "Car";

            Console.WriteLine("Old OrderID--->" + order.OrderID);
            Console.WriteLine("Old FirstName--->" + order.FirstName);

            OrderService srv = new OrderService();
            bool success=srv.PlaceOrder(order);

            Console.WriteLine("*******************************");
            Console.WriteLine("Processed OrderID--->" + order.OrderID);
            Console.WriteLine("Processed FirstName--->"+order.FirstName);
            Console.WriteLine("*******************************");
            Console.ReadLine();
        }
    }

就要好了，来看看效果图：

 Code