C# 用户锁定线程

我需要一种按用户锁定c#线程的方法

我有我的数据对象，我为每个用户创建新的实例。 每个用户都有几个线程使用这个对象，在I.O.操作中，我只想为这个用户锁定这个对象实例。 使用简单锁{}可以锁定所有对象实例，从而阻止其他用户

我需要一些简单的解决方案

编辑

我为每个用户构建

MyDataObj

的新实例； 然后每分钟运行更新

MyDataObj

中某些数据的作业； 使用

lockObj

作为锁，将数据锁定给所有用户（尽管它不是静态变量） 我只需要将数据锁定到当前用户

这是代码示例

public sealed class MyDataObj
{
    private static readonly Dictionary<object, MyDataObj> _instances = new Dictionary<object, MyDataObj>();
    public object lockObj = new object();
    public bool jobRunning = false;
    private string data = string.Empty;
    //// --------- constractor -------------------
    private MyDataObj(int key)
    {
        LoadMyDataObj(key);
    }

    public static MyDataObj GetInstance(int key)
    {
        lock (_instances)
        {
            MyDataObj instance;
            if (_instances.TryGetValue(key, out instance))
            {
                instance = _instances[key];
                return instance;
            }
            instance = new MyDataObj(key);
            return instance;
        }
    }

    private void LoadMyDataObj(int key)
    {
        // get the data from db

    }


    public void UpdateMyData(string newData)
    {
        lock (lockObj)
        {
            this.data = newData;
        }
    }
    public string ReadMyData()
    {
        lock (lockObj)
        {
            return this.data;
        }
    }



    public class ActionObject
    {
        MyDataObj myDataObj;
        int UserID;
        //// --------- constractor -------------------
        public ActionObject(int userid)
        {
            this.UserID = userid;
            myDataObj = MyDataObj.GetInstance(userid);
            if (!myDataObj.jobRunning)
            {
                jobs jbs = new jobs(myDataObj);
                System.Threading.Thread RunJob = new System.Threading.Thread(new System.Threading.ThreadStart(jbs.dominutesAssignment));
                RunJob.Start();
                myDataObj.jobRunning = true;
            }
        }
        public ActionObject()
        {
            myDataObj = MyDataObj.GetInstance(this.UserID);
            myDataObj.UpdateMyData("some data");
        }
    }


    public class jobs
    {
        MyDataObj myDataObj = null;

        public jobs(MyDataObj grp)
        {
            this.myDataObj = grp;
        }
        public void dominutesAssignment()
        {
            while (true)
            {
                myDataObj.ReadMyData();
                System.Threading.Thread.Sleep(1000);
            }
        }
    }
}

公共密封类MyDataObj
{
私有静态只读字典_实例=新字典（）；
public object lockObj=新对象（）；
public bool jobRunning=false；
私有字符串数据=string.Empty；
////------承包商-------------------
私有MyDataObj（整型密钥）
{
LoadMyDataObj（键）；
}
公共静态MyDataObj GetInstance（int键）
{
锁定（_个实例）
{
MyDataObj实例；
if（_instances.TryGetValue（key，out实例））
{
实例=_实例[键]；
返回实例；
}
实例=新的MyDataObj（键）；
返回实例；
}
}
私有void LoadMyDataObj（int键）
{
//从数据库中获取数据
}
public void UpdateMyData（字符串newData）
{
锁（lockObj）
{
this.data=newData；
}
}
公共字符串ReadMyData（）
{
锁（lockObj）
{
返回此.data；
}
}
公共类ActionObject
{
MyDataObj MyDataObj；
int用户标识；
////------承包商-------------------
公共操作对象（int userid）
{
this.UserID=UserID；
myDataObj=myDataObj.GetInstance（userid）；
如果（！myDataObj.jobRunning）
{
jobs jbs=新作业（myDataObj）；
System.Threading.Thread RunJob=new System.Threading.Thread（new System.Threading.ThreadStart（jbs.dominutesAssignment））；
RunJob.Start（）；
myDataObj.jobRunning=true；
}
}
公共操作对象（）
{
myDataObj=myDataObj.GetInstance（this.UserID）；
myDataObj.UpdateMyData（“某些数据”）；
}
}
公营职位
{
MyDataObj MyDataObj=null；
公共工作（MyDataObj grp）
{
this.myDataObj=grp；
}
公共无效域名分配（）
{
while（true）
{
myDataObj.ReadMyData（）；
系统线程线程睡眠（1000）；
}
}
}
}

您可以使用。在这个示例中，除了用户1之外，任何人都可以并发执行DoIt方法。当用户1执行DoIt时，没有人可以输入它。一个弱点是，如果用户1试图在用户2已经执行DoIt时执行DoIt，那么用户2将继续执行DoIt。此外，您还必须正确处理异常，否则可能会出现死锁

private static readonly object lockObj = new Object();

public void Do(int userId)
{
     Monitor.Enter(lockObj);

     if (userId != 1)
          Monitor.Exit(lockObj);

     try
     {
        DoIt();
     }
     finally 
     {
         if (userId == 1)
             Monitor.Exit(lockObj);
     }
}

public void DoIt()
{
    // Do It
}

我需要一种按用户锁定c#线程的方法。我有我的数据对象，我为每个用户创建新的实例

为每个用户创建一个锁。或者，如果用户存在的时间长于线程：则使用用户对象作为锁

lock (userOrTheUserObject)
{
    //Do some op
}

每个用户都有几个线程使用此对象和I.O.操作

这听起来更像是应该使用异步IO，而不是创建多个线程（这样效率会更低）

我只想为此用户锁定此对象实例。使用简单锁{}可以锁定所有对象实例，从而阻止其他用户

如果对象在所有用户之间共享，则必须使用

lock

锁定它。否则锁就不会很有效了。另一个对象是重新设计要共享的对象

我需要一些简单的解决方案

---

没有简单的线程解决方案。

这里的术语“锁定”是什么意思？您能发布当前如何锁定的代码吗？您的代码非常混乱。

MyDataObj

类包含一个静态字典，其中包含

MyDataObj

实例和访问它的方法、内部访问的实例方法和属性，以及一些访问

MyDataObj

方法的嵌套类。如果一位同事或员工要求我帮助调试，我会告诉他第一件事就是重构它。就目前情况而言，想弄清楚谁有权访问什么以及所有不同部分是如何相互作用的实在太难了。谢谢你的回答。我用。（静态字典的目的是确保每个用户都可以访问其MyDataObj的一个实例，这就是MyDataObj拥有私人承包商的原因）。ActionObject做2件事1）启动使用MyDataObj的作业，2）在MyDataObj上执行一些操作。如果是同一个用户，我只需要防止作业中断ActionObject。。。哇-这段代码让我想起了你是多么需要

尝试
和
最终
。如果
DoIt（）？锁将保留，这将导致死锁场景。另外：为什么不在这里简单地使用
lock（）
（事实上，这可以解决
尝试
和
最后的问题
）？事实是：如果您使用
lock（）
，不可能出现简单的死锁场景。因为他想根据用户动态更改锁的作用域，而我找不到使用
lock
实现它的方法。您可以：）。。。如果
/
else
：）无论如何：
使用C#try…finally块（Visual Basic中的try…finally）来确保释放监视器，或者使用C#lock语句（Visual Basic中的SyncLock语句），