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

  • Thread starter Thread starter Curious
  • Start date Start date
C

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!
 
1) I know "lock" is typically used in two methods. Will there be an
issue if "lock" is used in more than two methods?
Click to expand...

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?
Click to expand...

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.
 
Curious said:
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?
Click to expand...
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?
Click to expand...
What event objects? Neither event handling nor locking intrinsically create
objects.
 
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.
 
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?
 
Hi Andrew,

Thanks for the input!

FYI, I "lock" the section of the code in all of the three methods that
use the arraylist.
 
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.
 
Back
Top