asynchroonThreadAbort MDA
Notitie
Dit artikel is specifiek voor .NET Framework. Dit geldt niet voor nieuwere implementaties van .NET, waaronder .NET 6 en nieuwere versies.
De asynchronousThreadAbort beheerde foutopsporingsassistent (MDA) wordt geactiveerd wanneer een thread probeert een asynchrone abort in een andere thread te introduceren. Synchrone threads worden niet geactiveerd door de asynchronousThreadAbort MDA.
Symptomen
Een toepassing loopt vast met een niet-verwerkte ThreadAbortException bewerking wanneer de hoofdtoepassingsthread is afgebroken. Als de toepassing zou blijven worden uitgevoerd, kunnen de gevolgen slechter zijn dan de toepassing vastloopt, wat mogelijk leidt tot verdere beschadiging van gegevens.
Bewerkingen die zijn bedoeld om atomisch te zijn, zijn waarschijnlijk onderbroken na gedeeltelijke voltooiing, waardoor toepassingsgegevens in een onvoorspelbare status blijven. Een ThreadAbortException kan worden gegenereerd op basis van schijnbaar willekeurige punten in de uitvoering van code, vaak op plaatsen waar een uitzondering niet optreedt. De code kan een dergelijke uitzondering mogelijk niet verwerken, wat resulteert in een beschadigde status.
Symptomen kunnen sterk variëren vanwege de willekeurigheid die inherent is aan het probleem.
Oorzaak
Code in één thread genaamd de Thread.Abort methode op een doelthread om een asynchrone thread af te breken. De thread wordt asynchroon afgebroken omdat de code waarmee de aanroep wordt Abort uitgevoerd, wordt uitgevoerd op een andere thread dan het doel van de abort-bewerking. Synchrone threads mogen geen probleem veroorzaken omdat de thread die de Abort thread uitvoert, dit alleen heeft gedaan op een veilig controlepunt waar de toepassingsstatus consistent is.
Asynchrone threads afbreken een probleem omdat ze worden verwerkt op onvoorspelbare punten in de uitvoering van de doelthread. Om dit te voorkomen, moet code die wordt geschreven om te worden uitgevoerd op een thread die op deze manier kan worden afgebroken, een ThreadAbortException bijna elke regel code verwerken, waarbij toepassingsgegevens weer in een consistente status worden geplaatst. Het is niet realistisch om te verwachten dat code met dit probleem in gedachten wordt geschreven of dat code wordt geschreven die bescherming biedt tegen alle mogelijke omstandigheden.
Aanroepen naar niet-beheerde code en finally blokken worden niet asynchroon afgebroken, maar onmiddellijk na het verlaten van een van deze categorieën.
De oorzaak kan lastig zijn om te bepalen vanwege de willekeurigheid die inherent is aan het probleem.
Oplossing
Vermijd codeontwerp waarvoor het gebruik van asynchrone threads moet worden afgebroken. Er zijn verschillende benaderingen geschikter voor onderbreking van een doelthread waarvoor geen aanroep Abortis vereist. Het veiligste is om een mechanisme te introduceren, zoals een gemeenschappelijke eigenschap, dat de doelthread aangeeft om een interrupt aan te vragen. De doelthread controleert het signaal op bepaalde veilige controlepunten. Als het merkt dat er een interrupt is aangevraagd, kan deze probleemloos worden afgesloten.
Effect op de runtime
Deze MDA heeft geen effect op de CLR. Alleen gegevens over asynchrone threads worden afgebroken.
Uitvoer
De MDA rapporteert de id van de thread die de afgebroken en de id van de thread die het doel is van de afgebroken thread. Deze zullen nooit hetzelfde zijn omdat dit beperkt is tot asynchrone aborts.
Configuratie
<mdaConfig>
<assistants>
<asynchronousThreadAbort />
</assistants>
</mdaConfig>
Opmerking
Voor het activeren van de asynchronousThreadAbort MDA is alleen een aanroep vereist voor Abort een afzonderlijke actieve thread. Houd rekening met de gevolgen als de inhoud van de threadstartfunctie een reeks complexere bewerkingen was die mogelijk worden onderbroken op een willekeurig punt door het afbreken.
using System.Threading;
void FireMda()
{
Thread t = new Thread(delegate() { Thread.Sleep(1000); });
t.Start();
// The following line activates the MDA.
t.Abort();
t.Join();
}
