Thread.Abort()

[Alan T]

I will do several things in my thread:
Copy a file to a location
Update database record
Read the file content
Write the content to a log file

If I call Thread.Abort(), it may be possible to stop at the middle of the
something ?

 

[Guest]

Hi Alan,

Suspending and then Aborting a thread may cause data integrity problems if
your thread in middle of updating some business data. And anyway these two
methods are deprecated in .Net 2.0.

If your thread is doing some routine data related manipulations in a loop
(or some loop kind of thing), then implement a small class that wraps your
thread and provide "Pause", "Resume" and "Stop" methods on that class. Define
your thread handler method as a method inside the class and based on the
state of the class object ("Pause", "Resume" and "Stop") let the thread
handler method pause, resume and stop by itself.

This way you gurantee the data safety in your application and also provide a
decent way of pausing, resuming and stopping the work done by your thread.

 

[Alan T]

I partially understand your approach but not quite sure how to implement the
stop and resume.

The syntax is not proper, I just show the meaning:

Class MyThreadWrapper
private _myThread
private enumerated type _state (pause, stop, start, resume)
method Pause
{ set _state = pause}
method Stop
{ set _state = stop}
method Start
{ set _state = start
_myThread.Start()
}
method Resume
{ set _state = resume}

If the user calls MyThreadWrapper.State(),
_state will be set to start and calls


constructor :
_myThread = new Thread(new ThreadStart(this.DoSomething));

In the _myThread, it executes DoSomething(), to do a loop, for example 50
times:

procedure DoSomething()
loop
Copy a file to a location
Update database record
Read the file content
Write the content to a log file
end loop

1) If the user calls MyThreadWrapper.Start()

2) If the user calls MyThreadWrapper.Pause(), how do I guarrantee the loop
stops at after the
"Write the content to a log file" ? By checking the value of the _state?

procedure DoSomething()
loop
Copy a file to a location
Update database record
Read the file content
Write the content to a log file
while _state == pause
{
// no statement, so stay in this dummy while loop
}
end loop

2) What if the users calls MyThreadWrapper.Stop() ?
procedure DoSomething()
loop
Copy a file to a location
Update database record
Read the file content
Write the content to a log file
while _state == pause
{
// no statement
}
if _state == stop
{
exit;
}
end loop

Should it be like this:

procedure Stop()
{
_state = stop;
_myThread.abort();
}

Please comment

 

[Guest]

Hi Alan,

Here is how your class and thread method handler maylook like...

Class MyThreadWrapper
private _myThread

// (Important: Default state should be signaled, i.e. True)
private _continueEvent System.Threading.ManualResetEvent

private enumerated type _state (pause, stop, start, resume)
method Pause
{ set _state = pause, _continueEvent.Reset() }
method Stop
{ set _state = stop, _continueEvent.Set() }
method Start
{ set _state = start
_myThread.Start()
}
method Resume
{ set _state = resume, _continueEvent.Set() }

procedure DoSomething()
loop

_continueEvent.Wait(-1) // Wait infinitely on the manual reset event
if (_state == stop) { break; }

Copy a file to a location
Update database record
Read the file content
Write the content to a log file
end loop

What we are doing here is that the thread loop will just wait for
ManualResetEvent to be in signaled state (_continueEvent.Set()) before
continuing with every iteration in the loop. The event will be in this state
when the thread first starts. When we call Pause the_continueEvent will be in
non-signaled state and the thread will finish the current loop iteration and
then before begining the next iteration will wait for the event to be in
signaled state. When we call Resume after some time the _continueEvent will
be set to signaled state and the thread will start running again.

Calling Stop() when we are in running state (start or resume) will cause the
loop to terminate after completing its current iteration. Calling Stop() when
we are in pause state will set the _continueEvent to signaled state and
immediately since the _state is stop, the loop will break and the thread will
end safely.

Let me know if this helps.

 

[mabra]

Hi !

I just went to http://msdn2.microsoft.com/en-us/library/ty8d3wta.aspx to
verify your statement about the deprecation of this methods, but could
not verify.

Additionally, I would leave net immidiately;For example, if your
mentioned "copy a file to a location", would need too much time, because
the underlying system is not resposnible, I must have the option to kill
that thread and re-try the whole operation at a later moment. Naturally,
one has to deal with dataconsitency in this case very strong.

Just my two cents.
Best regards,
Manfred

 

[Willy Denoyette [MVP]]

| Hi !
|
| I just went to http://msdn2.microsoft.com/en-us/library/ty8d3wta.aspx to
| verify your statement about the deprecation of this methods, but could
| not verify.
|

Thread.Abort isn't deprecated but Thread.Suspend and Thread.Resume are.
Note that Thread.Abort should never be used to abort an other thread unless
you are willing to give up on the application domain your code is running
in, there are better way's to stop a thread from making progress, and don't
forget that Thread.Abort doesn't have any effect on a thread that is
executing in unmanaged land (like copy file).

Willy.