Multiple threads accessing same instance

Question

ObservableCollection<MyClass> collection = new ObservableCollection<MyClass>();
public MainWindow()
{
    InitializeComponent();
    collection.Add(new MyClass() { Name = "Vikram" });
    collection.Add(new MyClass() { Name = "Test" });          

    CallingTaskDelay();          
    MyClass class1 = collection[0];
    lock (class1)
    {
        txtName.Text = class1.Name;
    }
}

private Task TaskDelayMethod()
{           
    return Task.Run(() => ChangeItem());
}

private async void CallingTaskDelay()
{
    await TaskDelayMethod();
}

private void ChangeItem()
{
    MyClass myclass = collection[0];
    lock (myclass)
    {
        myclass.Name = "anup";
        Thread.Sleep(5000);
    }
}

While I am changing the content of the instance of the myclass in ChangeItem() method. I want to prevent access of the same instance in the MainWindow() method which I am doing as below -

lock (class1)
{
     txtName.Text = class1.Name;
}

How it can be accomplished. Mine is not working.

@SriramSakthivel the scenario which I have shown..it is not working here — Vikram, May 22 '14 at 06:18
Not working can have any meaning. Doesn't compile? Exception? Gives unexpected output? If so what ? Please explain. We can't guess — Sriram Sakthivel, May 22 '14 at 06:19
@SriramSakthivel : it means that, the case which I want is that as long as ChangeItem() is changing the content to "anup", I should not be able to access class1.Name in the MainMethod(). I hope you got what I want. Thanks :) — Vikram, May 22 '14 at 06:22
@Vikram [locking on the same object you are going to access is considered a bad practice](http://stackoverflow.com/questions/11775205/why-is-it-a-bad-practice-to-lock-the-object-we-are-going-to-change) — Vamsi, May 22 '14 at 06:32

score 0 · Answer 1 · answered May 22 '14 at 06:16

Usually it is better to have a private object to use as a lock, but what you are doing should work as long as MyClass is a reference type. I think the code in your constructor executes before ChangeItem starts and hence you are not seeing any contention. try putting a Thread.Sleep(1000) after CallingTaskDelay().

score 0 · Answer 2 · answered May 22 '14 at 06:26

I guess you have a "Race condition". ChangeItem is probably not called yet when you acquire lock (class1) in constructor. Otherwise your code should work as expected.

You can check it by adding some sleep.

CallingTaskDelay();
Thread.Sleep(100);//For debugging, just give some time for  `CallingTaskDelay` to call `ChangeItem`
MyClass class1 = collection[0];
lock (class1)
{
    txtName.Text = class1.Name;
}

score 0 · Answer 3 · answered May 22 '14 at 06:39

Are you expecting the ChangeItem() method to be run before the Constructor completes? Using the async keyword instructs the compiler to wait until it has nothing else to do before starting it. In the given scenario the ChangeItem() method will always be called After the Constructor completes

Multiple threads accessing same instance

3 Answers3