How to protect and access nested objects in multithreaded application - multithreading

Question

I have an object with nested objects. Simple diagram of object organziation would be:
TMainObj
-TState
-TDescriptor
-List<TSubObj>
--TSubObj_n
---TSubObjState
---TSubObjDesc
---TSubObjData
type TState = class
end;
type TDesc = class
end;
type TSubObjState = class
end;
type TSubObjDesc = class
end;
type TSubObjData = class
end;
type TSubObj = class
FSubObjState: TSubObjState;
FSubObjDesc: TSubObjDesc;
FSubObjData: TSubObjData;
end;
type TListSubObj = class (TList<TSubObj>)
end;
type TMainObj = class
FState: TState;
FDesc: TDesc;
FList: TList<TSubObj>
end;
I have multithreaded app and I have to enable access to objects and their properties (which are not included in this example code). Some threads share same objects some not but still they could share some properties with main thread therfore I need to protect data. I am protecting data with critical sections / mutexes. However I don't know how to organize locking mechanism in this scheme to get the best out of it.
My initial idea was to implement lock/unlock on TMainObj and whenever any thread needs to access any property or subobjects it will lock complete TMainObj and all other threads will need to wait until TMainObj becomes unlocked. For that reason I think this not really good idea. Some threads doesn't need to access TMainObj's properties but only it's sub object such as TState. I assume there is no need to lock whole TMainObj but only TState or am I missing something?
If I need to access properties on TMainObj I would do it:
TMainObj.Lock
try
TMainObj.Name := 'Just name!';
TManiObj.Id := 1;
finally
TMainObj.Unlock;
end;
And every other thread will have to wait to gain an access.
But what when I need to access sub class TDescriptor? I can do it like that:
TMainObj.Lock
try
TMainObj.Descriptor.DataLen := 1024;
TManiObj.Descriptor.Count := 10;
finally
TMainObj.Unlock;
end;
And complete TMainObj will be locked. And all other threads need to wait even if they are not 'interested' in changing TMainObj's properties.
Or that way to lock only sub object descriptor:
Thread1:
TMainObj.Descriptor.Lock
try
TMainObj.Descriptor.DataLen := 1024;
TManiObj.Descriptor.Count := 10;
finally
TMainObj.Descriptor.Unlock;
end;
Meanwhile some other thread can still access TMainObj properties and change them, right?
Thread2:
TMainObj.Lock;
try
TMainObj.Name := 'New name!';
finally
TMainObj.Unlock;
end;
Here is the image which shows how and what each thread is accessing.
One of concerns is a deadlock situation. In next case I would like to show how different threads are accessing different "part" of MainObj.
MainThread:
MainObj.Lock;
try
MainObj.Name = 'Different name!'
MainObj.Id = 2;
finally
MainObj.Unlock;
end;
Meanwhile thread1 is doing this:
MainObj.Descriptor.Lock;
try
MainObj.Descriptor.DataLen = 1024;
MainObj.Descriptor.Count = 1;
finally
MainObj.Descriptor.Unlock;
end;
So both are sharing MainObj but each is changing own part of object. Is that approach of locking appropriate?
I hope I explained my problem as clear as possible. My question is how to protect access to such object structure from different threads? Do I have to protect each subobject with it's own lock/unlock pair methods (and critical section)?

Answer 1

You could use TMonitor for this without adding anything to your objects. In that case your code would look like this:
TMonitor.Enter(MainObj.Descriptor);
try
MainObj.Descriptor.DataLen := 1024;
MainObj.Descriptor.Count := 10;
finally
TMonitor.Exit(MainObj.Descriptor);
end;
Provided all threads (and the main thread) that are trying to access descriptor do the same thing then they will lock waiting for the next thread to finish.
You will need to watch out for deadlocks but from what you say it shouldn't be a problem. A deadlock will occur if you do something like this:
Main Thread
Lock MainObj
Lock MainObj.Descriptor (waits for thread 1)
If thread 1 comes along and does this:
Thread 1
Lock MainObj.Descriptor
Lock MainObj (waits for main thread)