Use "lock" in three methods to prevent shared-memory corruption

[Curious]

I have an arraylist used in three separate methods.

In method #1 (event method), some items are removed from the arraylist
if certain conditions are met;

In method #2 (event method), properties of some items are modified if
certain conditions are met;

In method #3, it loops through each item in the arraylist without
changing any item on the arraylist or removing any item from the
arraylist. In other words, this is "read-only" type of operation.

Since both #1 and #2 are event methods and may happen anytime, there's
a chance that #1, #2, and #3 all happen at the same time, then I'll
run into a memory issue when one process is modifying the arraylist,
other process(es) are accessing the arraylist.

I plan to use "lock" in all of these three methods. I have questions:

1) I know "lock" is typically used in two methods. Will there be an
issue if "lock" is used in more than two methods?

2) If I use "lock" in #1 and #2, will locking the process cause the
associated **event objects** to expire since they are dynamic in
nature and only live for a very short period of time?

I would appreciate any input!

 

[Andrew Faust]

1) I know "lock" is typically used in two methods. Will there be an

issue if "lock" is used in more than two methods?

Not unless you create an issue. The more threads that are locking on an
object the higher chance of a programming error which could lead to
Deadlocks. If you're careful and think about all the ways the methods are
called you should be alright.

2) If I use "lock" in #1 and #2, will locking the process cause the
associated **event objects** to expire since they are dynamic in
nature and only live for a very short period of time?

No. An event can take milliseconds or hours to process. The only reason it
would "expire" is if the developer of the object that fired the event had
some kind of timeout built in to it. From what I've seen that's not standard
practice for most apps.

 

[Jeroen Mostert]

I have an arraylist used in three separate methods.

In method #1 (event method), some items are removed from the arraylist
if certain conditions are met;

In method #2 (event method), properties of some items are modified if
certain conditions are met;

In method #3, it loops through each item in the arraylist without
changing any item on the arraylist or removing any item from the
arraylist. In other words, this is "read-only" type of operation.

Since both #1 and #2 are event methods and may happen anytime, there's
a chance that #1, #2, and #3 all happen at the same time, then I'll
run into a memory issue when one process is modifying the arraylist,
other process(es) are accessing the arraylist.

I plan to use "lock" in all of these three methods. I have questions:

1) I know "lock" is typically used in two methods. Will there be an
issue if "lock" is used in more than two methods?

No. Locking ensures that only one piece of code can hold the lock at any one
time. It doesn't matter how many threads are trying that simultaneously
(though obviously performance suffers greatly if many threads are contending
for a single lock, but that's another matter altogether).

2) If I use "lock" in #1 and #2, will locking the process cause the
associated **event objects** to expire since they are dynamic in
nature and only live for a very short period of time?

What event objects? Neither event handling nor locking intrinsically create
objects.

 

[Jack Jackson]

Are you using multiple threads? You don't need to use locking unless
you have multiple threads.

If you are using VS2005 or later you should consider using the generic
List(Of T) rather than ArrayList.

 

[Curious]

Hi Jack,

Thanks for asking this!

#1 and #2 are on the same main thread, while #3 is on a separate timer
thread that runs every 15 seconds.

#1 and #2 are events and may happen at anytime. What happens if #1 and
#2 happen at the same time? Are they serizlized or do they step on
each other's feet?

 

[Curious]

Hi Andrew,

Thanks for the input!

FYI, I "lock" the section of the code in all of the three methods that
use the arraylist.

 

[Jack Jackson]

Events on the same thread do not interrupt each other.

If the timer is a System.Windows.Form.Timer then it runs on the main
UI thread and will not interrupt the other events.