Hoe een Java-thread te doden

1. Inleiding

In dit korte artikel, we behandelen het stoppen van een Draad in Java - wat niet zo eenvoudig is sinds de Thread.stop () methode is verouderd.

Zoals uitgelegd in deze update van Oracle, hou op() kan leiden tot beschadiging van bewaakte objecten.

2. Met behulp van een vlag

Laten we beginnen met een klas die een thread maakt en start. Deze taak zal niet vanzelf eindigen, dus we hebben een manier nodig om die thread te stoppen.

We gebruiken daarvoor een atoomvlag:

openbare klasse ControlSubThread implementeert Runnable {privé Thread-werker; privé finale AtomicBoolean running = nieuwe AtomicBoolean (false); privé int interval; openbare ControlSubThread (int sleepInterval) {interval = sleepInterval; } public void start () {worker = new Thread (this); worker.start (); } public void stop () {running.set (false); } public void run () {running.set (true); while (running.get ()) {probeer {Thread.sleep (interval); } catch (InterruptedException e) {Thread.currentThread (). interrupt (); System.out.println ("Thread is onderbroken, bewerking mislukt"); } // doe hier iets}}}

In plaats van een terwijl lus die een constante evalueert waargebruiken we een AtomicBoolean en nu kunnen we de uitvoering starten / stoppen door deze in te stellen op waar onwaar.

Zoals uitgelegd in onze inleiding tot Atomic Variables, met behulp van een AtomicBoolean voorkomt conflicten bij het instellen en controleren van de variabele van verschillende threads.

3. Onderbreken van een Draad

Wat gebeurt er wanneer slaap() is ingesteld op een lang interval, of als we wachten op een slot die misschien nooit wordt vrijgegeven?

We lopen het risico dat we voor een lange periode blokkeren of nooit netjes eindigen.

We kunnen het onderbreken() laten we voor deze situaties een paar methoden en een nieuwe vlag aan de klasse toevoegen:

openbare klasse ControlSubThread implementeert Runnable {privé Thread-werker; private AtomicBoolean running = nieuwe AtomicBoolean (false); privé int interval; // ... public void interrupt () {running.set (false); worker.interrupt (); } boolean isRunning () {return running.get (); } boolean isStopped () {terugkeer gestopt.get (); } public void run () {running.set (true); gestopt.set (false); while (running.get ()) {probeer {Thread.sleep (interval); } catch (InterruptedException e) {Thread.currentThread (). interrupt (); System.out.println ("Thread is onderbroken, bewerking is mislukt"); } // doe iets} stop.set (true); }} 

We hebben een onderbreken() methode die onze rennen vlag naar onwaar en roept het onderbreken() methode.

Als de draad slaapt wanneer dit wordt aangeroepen, slaap() zal afsluiten met een InterruptedException, net als elke andere blokkerende oproep.

Dit keert de thread terug naar de lus en wordt sindsdien afgesloten rennen is fout.

4. Conclusie

In deze korte tutorial hebben we gekeken naar het gebruik van een atomaire variabele, optioneel gecombineerd met een aanroep naar onderbreken(), om een ​​draad netjes af te sluiten. Dit verdient absoluut de voorkeur boven het aanroepen van het verouderde hou op() methode en riskeer voor altijd vergrendeling en geheugenbeschadiging.

Zoals altijd is de volledige broncode beschikbaar op GitHub.