Question

我的应用程序有两个部分，它们分别进行大量的插入和更新，因为管理不善，就会出现死锁。

我正在使用实体框架来进行插入和更新。

以下是我的TestSpool程序的代码。该程序的目的是以给定的间隔插入x个记录。

using System;
using System.Linq;
using System.Threading;
using System.Transactions;
namespace TestSpool
{
    class Program
    {
        static void Main(string[] args)
        {
            using (var db = new TestEntities())
            {
                decimal start = 700001;
                while (true)
                {
                    using (TransactionScope scope = new TransactionScope())
                    {
                        //Random ir = new Random();
                        //int i = ir.Next(1, 50);
                        var objs = db.BidItems.Where(m => m.BidItem_Close == false);
                        foreach (BidItem bi in objs)
                        {
                            for (int j = 0; j <= 10; j++)
                            {
                                Transaction t = new Transaction();
                                t.Item_Id = bi.BidItemId;
                                t.User_Id = "Ghost";
                                t.Trans_Price = start;
                                t.Trans_TimeStamp = DateTime.Now;
                                start += 10;
                                db.Transactions.AddObject(t);

                            }
                            Console.WriteLine("Test Spooled for item " + bi.BidItemId.ToString() + " of " + 11 + " bids");
                            db.SaveChanges();
                        }

                        scope.Complete();
                        Thread.Sleep(5000);
                    }
                }
            }
        }
    }
}

程序的第二部分是testserverclass，服务器类应该从testspool处理大量事务并确定最高的事务量并更新到另一个表。

using System;
using System.Linq;
using System.Transactions;
public class TestServerClass
{

    public void Start()
    {
        try
        {

            using (var db = new TestServer.TestEntities())
            {

                while (true)
                {
                    using (TransactionScope scope = new TransactionScope())
                    {
                        var objsItems = db.BidItems.Where(m => m.BidItem_Close == false);
                        foreach (TestServer.BidItem bi in objsItems)
                        {
                            var trans = db.Transactions.Where(m => m.Trans_Proceesed == null && m.Item_Id == bi.BidItemId).OrderBy(m => m.Trans_TimeStamp).Take(100);

                            if (trans.Count() > 0)
                            {
                                var tran = trans.OrderByDescending(m => m.Trans_Price).FirstOrDefault();

                                // TestServer.BidItem bi = db.BidItems.FirstOrDefault(m => m.BidItemId == itemid);
                                if (bi != null)
                                {
                                    bi.BidMinBid_LastBid_TimeStamp = tran.Trans_TimeStamp;
                                    bi.BidMinBid_LastBidAmount = tran.Trans_Price;
                                    bi.BidMinBid_LastBidBy = tran.User_Id;

                                }
                                foreach (var t in trans)
                                {
                                    t.Trans_Proceesed = "1";
                                    db.Transactions.ApplyCurrentValues(t);
                                }

                                db.BidItems.ApplyCurrentValues(bi);
                                Console.WriteLine("Processed " + trans.Count() + " bids for Item " + bi.BidItemId);
                                db.SaveChanges();

                            }


                        }
                        scope.Complete();

                    }

                }

            }


        }
        catch (Exception e)
        {
            Start();
        }
    }

}

但是，当两个应用程序同时运行时，它将从第一个测试或服务器应用程序中随机快速地进入死锁状态。我如何为双方优化我的代码以防止死锁？我期待来自testspool应用程序的大量插入。

Answer 1

由于他们处理相同的数据并以彼此的方式进行，我相信最简单的方法是避免同时执行这两个数据。

在数据库上定义一个全局静态变量，或某种互斥或某种标志。无论谁开始执行都会抬起旗帜，其他人等待旗帜下降。当旗帜下降时，另一个旗帜抬起旗帜并开始执行。

为了避免每个课程的等待时间过长，您可以更改两个课程，以便每回合只处理有限数量的记录。您还应该为该标志引入最长等待时间。应仔细选择最大记录限制，以确保每个班级在比最长等待时间更短的时间内完成工作。

多个插入和更新导致死锁c＃

1 个答案: