线程终止和线程。中止()

Why not ALWAYS? In which cases it doesn't termenate the thread?

For starters, a thread may catch a ThreadAbortException and cancel its own termination. Or it could perform a computation that takes forever while you're trying to abort it. Because of this, the runtime can't guarantee that the thread will always terminate after you ask it to.

ThreadAbortException has more:

When a call is made to the Abort method to destroy a thread, the common language runtime throws a ThreadAbortException. ThreadAbortException is a special exception that can be caught, but it will automatically be raised again at the end of the catch block. When this exception is raised, the runtime executes all the finally blocks before ending the thread. Since the thread can do an unbounded computation in the finally blocks, or call Thread.ResetAbort() to cancel the abort, there is no guarantee that the thread will ever end.

You don't need to Abort() a thread manually. The CLR will do all of the dirty work for you if you simply let the method in the thread return; that will end the thread normally.

I've had cases where the thread has been too busy to hear the Abort() call, which usually results in a ThreadAbortingException being thrown to my code.

What if a thread is holding a lock and is aborted / killed ? Resources remain stuck

It works fine when when a thread calls abort itself but not by other thread. Abort, forcefully terminates the affected thread even if it has not completed its task and provides no opportunity for the cleanup of resources

reference MSDN

see: Managed Threading Best Practices

Thread.Abort() injects a ThreadAbortException on the thread. The thread may cancel the request by calling Thread.ResetAbort(). Also, there are certain code parts, such as finally block that will execute before the exception is handled. If for some reason the thread is stuck in such a block the exception will never be raised on the thread.

As the caller has very little control over the state of the thread when calling Abort(), it is generally not advisable to do so. Pass a message to the thread requesting termination instead.

OT: For a comprehensive, language-agnostic, questionably useful and darned funny take on concurrency, see Verity Stob!

ThreadAborts will not occur inside a finally block or between BeginCriticalRegion and EndCriticalRegion

Because you can catch the ThreadAbortException and call Thread.ResetAbort inside the handler.

In which cases it doesn't terminate the thread?

This question is a duplicate.

What's wrong with using Thread.Abort()

Are there any other posibility to terminate threads?

Yes. Your problem is that you should never start up a thread that you cannot tell politely to stop, and it stops in a timely manner. If you are in a situation where you have to start up a thread that might be (1) hard to stop, (2) buggy, or worst of all (3) hostile to the user, then the right thing to do is to make a new process, start the thread in the new process, and then terminate the process when you want the thread to go down. The only thing that can guarantee safe termination of an uncooperative thread is the operating system taking down its entire process.

See my excessively long answer to this question for more details:

Using lock statement within a loop in C#

The relevant bit is the bit at the end where I discuss what the considerations are regarding how long you should wait for a thread to kill itself before you abort it.

FileStream.Read() to a named pipe that is currently not receiving anything (read call blocks while waiting for incoming data) will not respond to Thread.Abort(). It remains inside the Read() call.

I can't seem to abort a thread that is stuck in a loop:

//immortal
Thread th1 = new Thread(() => { while (true) {}});

I can however abort the thread if sleeps during the loop:

//mortal
Thread th2 = new Thread(() => { while (true) { Thread.Sleep(1000); }});

As john feminella stated from MSDN

When this exception is raised, the runtime executes all the finally blocks before ending the thread.

For example this Abort never ends:

var thread = new Thread(action) { IsBackground = true };
thread.Start();
Thread.Sleep(2000);
thread.Abort();


while (!thread.Join(1000))
{
Console.WriteLine(thread.ThreadState);
}


void action()
{
try
{
while (true) { }
}
catch { }
finally
{
while (true) { }
}
}