petshop异步和多线程

最近异步和多线程一直困扰着我，我也将用一定的时间去慢慢的理解。突然想到petshop里面有用到异步和多线程，自己也看了，还是总结下好。

首先，要讲petshop的异步还是要从order订单策略开始讲起，先看下IBLLStrategy.IOrderStrategy这个接口：

public interface IOrderStrategy  {

        void Insert(PetShop.Model.OrderInfo order);
    }

 然后看下BLL对订单的两种实现方式，一种是异步一种是同步的，同步的就不必多说了，就直接看下异步的吧：

public class OrderAsynchronous : IOrderStrategy
    {
        // Get an instance of the MessagingFactory
        // Making this static will cache the Messaging instance after the initial load
        private static readonly PetShop.IMessaging.IOrder asynchOrder = PetShop.MessagingFactory.QueueAccess.CreateOrder();

        /// <summary>
        /// This method serializes the order object and send it to the queue for asynchronous processing
        /// </summary>
        /// <param name="order">All information about the order</param>
        public void Insert(PetShop.Model.OrderInfo order) {

            asynchOrder.Send(order);
        }
    }

 这个OrderAsynchronous的实现是通过MessagingFactory工厂类来发送order消息的，具体怎么实现这边就不细说了，由于本人的博客一般地写给自己看，所以就没有写得那么详细了。

这个订单的异步是分两步进行的：第一，吧订单插入到消息队列中，第二，做一个后台的控制程序，实时地吧消息队列的值插入到数据库中。这样的话更好的提高网站的性能。

那么，这个时候是不是要来看下这个后台的控制程序是怎么运行的呢？

static void Main() {

            Thread workTicketThread;
            Thread[] workerThreads = new Thread[threadCount];

            for (int i = 0; i < threadCount; i++) {

                workTicketThread = new Thread(new ThreadStart(ProcessOrders));

                // Make this a background thread, so it will terminate when the main thread/process is de-activated
                workTicketThread.IsBackground = true;
                workTicketThread.SetApartmentState(ApartmentState.STA);

                // Start the Work
                workTicketThread.Start();
                workerThreads[i] = workTicketThread;
            }

            Console.WriteLine("Processing started. Press Enter to stop.");
            Console.ReadLine();
            Console.WriteLine("Aborting Threads. Press wait...");

            //abort all threads
            for (int i = 0; i < workerThreads.Length; i++) {

                workerThreads[i].Abort();
            }

            Console.WriteLine();
            Console.WriteLine(totalOrdersProcessed + " Orders processed.");
            Console.WriteLine("Processing stopped. Press Enter to exit.");
            Console.ReadLine();
        }

        /// <summary>
        /// Process a batch of asynchronous orders from the queue and submit them to the database within a transaction
        /// </summary>
        private static void ProcessOrders() {

            // the transaction timeout should be long enough to handle all of orders in the batch
            TimeSpan tsTimeout = TimeSpan.FromSeconds(Convert.ToDouble(transactionTimeout * batchSize));

            Order order = new Order();
            while (true) {

                // queue timeout variables
                TimeSpan datetimeStarting = new TimeSpan(DateTime.Now.Ticks);
                double elapsedTime = 0;

                int processedItems = 0;

                ArrayList queueOrders = new ArrayList();

                //OrderInfo orderData = orderQueue.Receive(timeout);
                using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, tsTimeout)) {
                    // Receive the orders from the queue
                    for (int j = 0; j < batchSize; j++) {

                        try {
                            //only receive more queued orders if there is enough time
                            if ((elapsedTime + queueTimeout + transactionTimeout) < tsTimeout.TotalSeconds) {
                                queueOrders.Add(order.ReceiveFromQueue(queueTimeout));
                            }
                            else {
                                j = batchSize;   // exit loop
                            }

                            //update elapsed time
                            elapsedTime = new TimeSpan(DateTime.Now.Ticks).TotalSeconds - datetimeStarting.TotalSeconds;
                        }
                        catch (TimeoutException) {

                            //exit loop because no more messages are waiting
                            j = batchSize;
                        }
                    }

                    //process the queued orders
                    for (int k = 0; k < queueOrders.Count; k++) {
                        order.Insert((OrderInfo)queueOrders[k]);
                        processedItems++;
                        totalOrdersProcessed++;
                    }

                    //batch complete or MSMQ receive timed out
                    ts.Complete();
                }

                Console.WriteLine("(Thread Id " + Thread.CurrentThread.ManagedThreadId + ") batch finished, " + processedItems + " items, in " + elapsedTime.ToString() + " seconds.");
            }
        }

 首先，定义了线程数组，这里的threadcount是2，那么 就是两个线程同时在运行，提高执行效率。然后看下线程执行的函数ProcessOrders吧，他可以分为两步，第一是吧消息队列的值ArrayList，然后再从中取值，最后插入到数据库中。

这边的异步是人为的都，二并非某某的Begin** End**.

 

---212-7-25

之前对为什么这边会用多线程没有多加思考，只觉得用了多线程就是好，但是多线程该怎么样，何时用？下面贴出我今晚测试的代码：

public static void DoSomeWork()
		{
			///构造显示字符串
			string results = "";

			///创建一个Sigleton实例
            CountSigleton MyCounter = new CountSigleton().Instance();

			///循环调用四次
			for(int i=1;i<5;i++)
			{
				///开始计数
				MyCounter.Add();
                
				results +="线程";
				results += Thread.CurrentThread.Name + "——〉";
				results += "当前的计数：";
				results += MyCounter.GetCounter().ToString();
				results += "\n";
                Console.WriteLine(Thread.CurrentThread.IsThreadPoolThread+"\n");
				Console.WriteLine(results);
				
				///清空显示字符串
				results = "";
			}
		}

为了不产生误解，我把CountSigleton类也贴出来，之前这个类是一个单例模式的，我改了。

public class CountSigleton
	{
		///存储唯一的实例
        private CountSigleton uniCounter;
   
		///存储计数值
		private int totNum = 0;  
   
		public CountSigleton() 
   
		{ 
			///线程延迟2000毫秒
			Thread.Sleep(2000);
		} 
   
	    public CountSigleton Instance() 
   
		{
            uniCounter = new CountSigleton(); 
			return uniCounter; 
   
		} 
		
		///计数加1
		public void Add()
		{ 
			totNum ++;
		}  
		
		///获得当前计数值
		public int GetCounter()
		{ 
			return totNum;
		} 

然后来看看多线程调用吧：

 Thread threadTest;
            Thread[] workerThreads = new Thread[2];
            for (int i = 0; i < 2; i++)
            {
                threadTest = new Thread(new ThreadStart(DoSomeWork));
                threadTest.Name = "thread" + i;
                threadTest.SetApartmentState(ApartmentState.STA);
                threadTest.IsBackground = true;
                workerThreads[i] = threadTest;
                threadTest.Start();
            }

这边是两个线程，直接看控制台输出的结果吧，看结果比较好说明什么：

 

这就有点像线程的两次运行，这样的结果显然不是我们想得到的。

那么这样的多线程到底有什么作用呢？好的，原归正状，petshop这边消息队列为什么要用多线程呢？

因为，这样可以跟快的事实的去取到消息队列的值。这边就是多线程的魅力所在。