How to manually kill a specific (running) thread from Visual Studio - c#

For the purpose of testing, I need to manually kill a named thread (in a debugging session) from Visual Studio - or any other tool that allows me to do that?
But the Threads Debug Window in Visual Studio 2010 only has a Freeze option in the thread's context menu, and Sysinternal's ProcessExplorer only lists processes, not threads.
Is there a way to manually kill a specific (running) thread?

It's not easy to just kill a thread because the designers of the language want to avoid the following problem: your thread takes a lock, and then you kill it before it can release it... now anyone who needs that lock will get stuck.
What you have to do is use some global variable to tell the thread to stop. You have to manually, in your thread code, check that global variable and return if you see it indicates you should stop.

Related

Visual Studio is not stopping even after closing the app in debug mode

I am developing a windows form in c#. It is working fine but when I am running it in debug mode, I can see that visual studio is not stopping even after closing the form.
Below are some screenshots-
and
Probably my app is not releasing any resource. How can I deal with this problem? How to know which resource is still in use?
This can happen if you are using ApplicationContext instead of a form as the default message queue. If so, consider handling the form closing event of your form.
When I have seen this issue in the past it was because my application hasn't actually exited. This would most likely be because you or a dependency still has a thread running that hasn't stopped. You can tell if this is the case by looking at the task manager and checking for yourapplication.exe or yourapplication.vshost.exe. If either of these is open in the task manager you can kill it.
To fix this issue, make sure you call Abort() on all threads!
You might want to try looking at the Processes from Start Task Manager. That could give you some information if a third party process initiated by the application is still running.

Why doesn't visual studio exit the debugger on application exit?

I am trying to figure out what changed within a project that now causes the application to not exit the debugger when I close the application I am debugging. I have also noticed that unhandled exceptions no longer invoke the unhandled exception handler, I am not sure if it's related.
This is probably due to other threads, which are not set as background threads, keeping the application alive. Background threads will terminate when the application does, whereas foreground threads will keep the rest of the application alive until they complete.
One way to check for the thread(s) that are responsible is in the debugger, as follows:
Run your app in the debugger
"Exit" your app.
Wait until the app should have exited but hasn't
Break into the app using the "pause" button
Open the "Threads" debugging window
Look for any threads in this window. Chances are there will be one, or a few threads showing. See if you can identify what they are by the info in the window.
It may also help to open the "Stack" debugging window and then double-click on each thread in the "Threads" window in turn and look at the contents of the "Stack" window. You may be able to see what any stuck threads are trying to do.
The debugger exits when all the threads exit. You've probably created an extra thread and done nothing to terminate it.
And this would explain unhandled exceptions being uncaught: if they happen on a different thread you won't see them on the main thread.
Most certainly the application has not actually terminated. Do you have any other threads running? An application will not shut down until all foreground threads have terminated.

How to see background threads in Visual Studio 2010 debugger

I'm trying to figure out why the application process lingers in Task Manager after the application is closed and the window disappears.
When I get VS to attach to the zombie process and break all, the threads window shows that the main thread is still alive, and a number of worker threads as well.
Some questions:
Are worker threads necessarily background threads? If not, how do I identify the background threads as I didn't see such a column in the window?
Do I simply double-click on each thread in the thread window, and watch the Thread.IsBackgroundThread value?
When I click on the main thread, the debugger doesn't show a call stack. How
do I identify where the main thread is stuck?
I would strongly sugest you tu use WinDbg. It is not a visual debugger though it is much more powerful.
Surely I will figure you out.
To list all threads in a process use: ~.
To switch to a certain thread ~thread_ids.
To see stak of curent thread !clr_stack.
Brief tutorial.
http://www.codeproject.com/KB/debug/windbg_part1.aspx
Also try in google "Debuging Asp.net with windbg"

Reason why my application would not exit?

We have an application written in .net, c#, winforms. We noticed that sometimes when closing the application, the process remains.
I'm not sure how I can reproduce that behavior, so I'm looking for some clues as to why the application wouldn't exit.
The application uses a bit of background threads. Thread pools. Wondering if that could be the cause. Anything else could have this effect?
If you have thread's that have IsBackground property set to false that are alive after application is closed, they will remain
The application uses a bit of
background threads. Thread pools.
Wondering if that could be the cause.
Anything else could have this effect?
It most definitely could be the cause though I cannot be certain that it actually is. One way to test this hypothesis to make sure all threads that have been explicitly created are designated as background threads. This can be done by setting Thread.IsBackground = true which will allow the application to terminate if the main thread ends. If there is at least one thread for which IsBackground = false then the CLR keeps the host process running.
Its likely to be a thread left running. If you have a look at the process in task manager you can see when a thread starts, and how many are left running when it exits by adding the 'Threads' column from the view menu.
I would start by making sure you start and end on the same thread count.
Get Process Explorer and possibly Process Monitor and see what thread is left suspended or running.
If you are able to run in debug and you close the form, VS should not return to the normal code edit mode (it will still have the pause and stop buttons from debug active). You can then press Pause and check the Threads window to see where the call stacks are stuck for threads that are still active.

Is it possible to use process explorer to kill a recursive loop generated in visual studio?

Sometimes I incorrectly code something and I create a thread that enters a never ending loop. this means I have to shut down the entire visual studio. Is it possible to use process explorer to inspect the visual studio process and shut down the thread that is killing the cpu?
Pete
Erm... yes? Normally you can just press "stop" (shift+f5) when debugging, but otherwise just locate your app (in task manager or any other tool; typically just a case of sorting by CPU usage) and end the process. VS will treat that as your process exiting, but VS itself should be fairly unharmed.
No, you can't use Process Explorer to kill a single thread. You kill the entire process. You could use SysInternals procexp.exe to analyze processes and threads and kill only a single thread within a given process. Very nifty tool. But in general avoid coding never ending loops :-)
Yes you can.
But doesn't the Visual Studio Debugger have an 'stop'-button or something alike?

Categories

Resources