关于设计模式的问题：这样的系统应该如何设计？

对设计模式不是很熟悉，现在碰到一个比较棘手的问题，不知道应该如何设计，请大家帮忙看一看。

现在有两种用于快速处理订单的业务A、业务B，分别用于处理订单A和订单B，他们的逻辑都是相似的，基本逻辑就是：

（1）初始化业务的各项基础数据
（2）接受一个订单，放入到待处理订单缓冲
（3）从待处理缓冲读取一个订单并开始处理，并将处理完的订单放入到已处理缓冲
（4）定期检测已处理缓存，当已处理缓冲区达到一定数量之后就同步写入数据库

上述逻辑的设计是考虑到订单的数量非常庞大（高峰时段每秒需要接受10~100个订单），并且订单发出后用户无需等待处理状态，所有订单在第二步都是可以成功处理的。每个订单如果即时写入数据库，会造成数据库无法负担。因此业务Ａ和业务Ｂ都包含下列线程：
（1）主线程：用于接受客户端请求
（2）初始线程：完成系统初始化
（3）处理线程：处理队列
（4）同步更新线程：更新到数据库

系统采用.Net   Remoting技术进行部署，为了减少并发冲突，我的想法是：主线程使用实例变量形式，而待处理缓冲和已处理缓冲都采用静态变量形式，响应的初始线程、 处理线程和同步更新线程都均采用静态变量形式。因此我打算写一个基础类，业务Ａ和业务Ｂ都该基础类进行继承，基类的代码可以简单概况为：

C# code

                        
<!--
                        Code highlighting produced by Actipro CodeHighlighter (freeware)
                        http://www.CodeHighlighter.com/
                        -->
                        using System;
                        using System.Data;
                        using System.Data.SqlClient;
                        using System.Configuration;
                        using System.Collections;
                        using System.Collections.Specialized;
                        using System.Collections.Generic;
                        using System.Threading;
                        using System.Text;
                        namespace MyProgram
                        {
                        public class OrderBaseObj : MarshalByRefObject
                        {
                        // 待处理订单列表
                                protected static List<OrderItem> lstUnHandle = new List<OrderItem>();
                        // 已处理订单列表
                                protected static List<OrderItem> lstHandle = new List<OrderItem>();
                        // 初始化是否完成标记
                                protected static bool blnInitFinished = false;
                        // 待执行的数据库事务表
                                protected static List<string> lstUpdateCommand = new List<string>();
                        // 初始化线程
                                protected static Thread threadInit = null;
                        // 处理线程
                                protected static Thread threadHandle = null;
                        // 数据库同步线程
                                protected static Thread threadDB = null;
                        static OrderBaseObj()
                        {
                        ThreadStart tst = new ThreadStart(ThreadInit_Start);
                        threadInit = new Thread(tst);
                        threadInit.Priority = ThreadPriority.BelowNormal;
                        threadInit.Start();
                        tst = new ThreadStart(ThreadHandle_Start);
                        threadHandle = new Thread(tst);
                        threadHandle.Priority = ThreadPriority.Lowest;
                        threadHandle.Start();
                        tst = new ThreadStart(ThreadDB_Start);
                        threadDB = new Thread(tst);
                        threadDB.Priority = ThreadPriority.Lowest;
                        threadDB.Start();
                        }
                        /// <summary>
                        /// 添加一个PV到待处理区
                        /// </summary>
                                public void AddPV(OrderItem order)
                        {
                        lstUnHandle.Add(order);
                        }
                        // 初始线程启动方法
                                private static void ThreadInit_Start()
                        {
                        Init();
                        blnInitFinished = true;
                        }
                        // 初始化抽象方法
                                protected static abstract bool Init();
                        // 处理线程启动方法
                                private static void ThreadHandle_Start()
                        {
                        while (true)
                        {
                        OrderItem order=lstUnHandle[0];
                        lstUnHandle.RemoveAt(0);
                        HandleOrder(order);
                        lstHandle.Add(order);
                        if(lstHandle.Count>100)
                        {
                        string strCommmand=HandleUpdateCommmand();
                        lstUpdateTrans.Add(strCommand);
                        lstHandle.Clear();
                        }
                        }
                        }
                        // 订单处理的抽象方法，每个子类必须实现该方法
                                protected abstract static void HandleOrder(OrderItem order);
                        // 返回处理数据库同步更新命令
                                protected abstract static string HandleUpdateCommmand();
                        // 同步线程启动方法
                                private static void ThreadDB_Start()
                        {
                        while (true)
                        {
                        if (lstUpdateTrans.Count > 0)
                        {
                        string strCommand=lstUpdateTrans[0];
                        lstUpdateTrans.RemoveAt(0);
                        DBObj db=new DBObj();
                        db.Execute(strCommand);
                        db.CloseConn();
                        }
                        Thread.Sleep(new TimeSpan(0, 0, 2));
                        }
                        }
                        }
                        }
                        

                        

上面代码的问题就是：静态方法不能描述为抽象方法，如果不采用基类的方式，直接在业务A或者业务B里面实现，上面的思路是没有问题的（不采用抽象方法），当然很多代码会重复，如果需要增加订单类型，就要增加业务类，维护起来不方便。

如果一定要实现一个基类，那么这么基类应该怎么写呢？