C# Locking from events

Question

Is there a construct in c# that is like lock { }, but works when called from an event handler i.e. waits for the code block to complete before handling a subsequent event.

The problem I am having is that lock { } only prevents other threads from obtaining a lock on the object, but if an event handler on the same thread is called, the execution of code within the lock block is interrupted, and the new event is handled before returning to the execution of the original code.

object DoStuffLock = new object(); public void DoStuff() { lock (DoStuffLock) { // Do stuff that we don't want to be interrupted, // but because it is called from an event handler // it still can be interrupted despite the lock } }

I am currently working around the problem like this (but it is hardly ideal):

object DoStuffLock = new object(); // this gets called from an event, and therefore can be interrupted, // locking does not help, so launch separate thread public void DoStuff() { var x = new Thread(DoStuffInternal); x.Start(); } private void DoStuffInternal() { lock (DoStuffLock) { // Do stuff that we don't want to be interrupted } }

A thread cannot be 'interrupted' by an event. You haven't diagnosed the real problem. — Hans Passant
– Hans Passant, Commented Apr 5, 2011 at 20:06
Indeed - you are correct - I hadn't diagnosed the real problem. — Matthew Richardson
– Matthew Richardson, Commented Apr 5, 2011 at 20:47

Reed Copsey · Accepted Answer · 2011-04-05 19:34:18Z

4

The problem I am having is that lock { } only prevents other threads from obtaining a lock on the object, but if an event handler on the same thread is called

This really can't happen. If your thread is executing, an event can't occur on the same thread - it would have to be raised on a different thread.

That being said, your "second approach" is, in many ways, superior in any case. There's an implicit assumption that event handlers will return very quickly. A "blocking" event handler is typically a sign of a bad design, and will potentially cause problems, especially since the event publisher will not be expecting the event to block.

answered Apr 5, 2011 at 19:34

Reed Copsey

567k80 gold badges1.2k silver badges1.4k bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Matthew Richardson Over a year ago

The event in question is fired by a FileSystemWatcher, and the code in DoStuff() returns very quickly. Despite this, if the FileSystemWatcher fire multiple events in very quick succession (and it often does), the code in DoStuff() gets interrupted to handle the new event.

Reed Copsey Over a year ago

@Matthew: You can do the lock without a separate thread. FileSystemWatcher raises events on a threadpool thread - so your lock would work fine there. It will never raise it on the same thread, since your code is executing. As a result, it will never interrupt your code - it may run 2 copies simultaneously (which makes the debugger look like it's interuptting, but check the threads window..). If this isn't desirable, a lock in your method will protect it without the need for a separate thread launch.

Matthew Richardson Over a year ago

You are of course correct - the problem lay elsewhere - and running the locked code in a separate thread just appeared to "fix" the problem by delaying its execution - thanks for insisting that I was was wrong and making me recheck everything for a second time.

Yochai Timmer · Accepted Answer · 2011-04-05 19:36:43Z

Think about locking code, not the object.

Use the same lock object to lock pieces of code that can't be entered simultaneously.

Besides, Locks don't stop interruption, they just stop access to the same piece of code from 2 threads simultaneously.

Erik Funkenbusch · Accepted Answer · 2011-04-05 19:43:07Z

UI events are all called fromt the same thread. lock is designed to protect from multiple threads. lock is specifically designed to allow the same thread to call the same lock more than once, otherwise a deadlock can occur.

I think your second solution is the correct one. If you have some piece of code that must execute in a block, then you execute it on a new thread.

mike · Accepted Answer · 2011-04-05 19:45:45Z

In operating systems like Windows you can not make any assumptions about the order of events handling. This can be done only with real time operating systems.

What you can do in your case is you could increase your thread priority. That should give your thread more time (relative to other threads). More info about threads priority in .net can be found here: http://msdn.microsoft.com/en-us/library/system.threading.threadpriority.aspx

Collectives™ on Stack Overflow

C# Locking from events

4 Answers 4

3 Comments

Comments

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

3 Comments

Comments

Comments

Comments

Linked

Related