• Startseite
  • Artikel
  • Allgemein
  • Wie kann man lange laufende Java-Threads zur Laufzeit stoppen/beenden? timed-out -> abgebrochen -> unterbrochene Zustände

Wie kann man lange laufende Java-Threads zur Laufzeit stoppen/beenden? timed-out -> abgebrochen -> unterbrochene Zustände

Veröffentlicht: 2021-07-17

Wie kann man Java-Threads beenden, die länger als erwartet dauern? timedout -> abgebrochen -> unterbrochener Zustand

Haben Sie sich jemals gefragt, wie Sie lange laufende Java-Threads beenden können? Haben Sie eine der folgenden Fragen?

  • Einen Thread nach einer bestimmten Zeit beenden/stoppen
  • Beenden von Threads nach einem bestimmten Zeitlimit in Java
  • So beenden Sie einen Java-Thread
  • So stoppen Sie einen Thread in Java mit einem Beispiel
  • So stoppen Sie Threads in einem Java-Codebeispiel
  • Wie man einen Thread in Java stoppt, ohne die Stop-Methode zu verwenden

Wenn Sie eine der folgenden Fragen haben, sind Sie hier richtig. Heute werden wir ein einfaches Beispiel durchgehen, das Java8-Methoden zum Beenden lang laufender Threads demonstriert.

Was ist eine Logik:

  1. Erstellen Sie die Klasse CrunchifyJavaTaskTimeout.java
  2. Erstellen Sie einen Java-Thread-Executor mit nur einer Threadpool-Größe.
  3. Erstellen Sie 4 zukünftige Aufgaben eines CrunchifyRunner Objekts mit einem Timeout von 3 Sekunden
  4. CrunchifyRunner.java ist eine einfache Klasse, die die Methode call() implementiert
    • Es führt eine Verzögerung von 20 seconds ein, wenn futureTask = 4
  5. Sobald future die 3 seconds -Zeit erreicht, wird eine Timeout-Ausnahme erstellt, wenn der Thread noch ausgeführt wird
    • Sobald die Zeit abgelaufen ist, müssen wir die Aufgabe mit crunchifyFuture abbrechen. cancel( true ) ;
    • Sobald futureTask abgebrochen wird, wird InterruptedException ausgelöst (wird ausgelöst, wenn ein Thread wartet, schläft oder anderweitig belegt ist und der Thread entweder vor oder während der Aktivität unterbrochen wird. Gelegentlich möchte eine Methode möglicherweise testen, ob der aktuelle Thread unterbrochen wurde, und wenn ja, um diese Ausnahme sofort auszulösen.)

Lass uns anfangen:

Schritt-1 Erstellen Sie die CrunchifyRunner.java-Klasse

CrunchifyRunner.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package crunchify . java . tutorials ;
 
import java . text . SimpleDateFormat ;
import java . util . Date ;
import java . util . concurrent . Callable ;
 
/**
* @author Crunchify.com
* Version: 1.0.1
*
*/
 
public class CrunchifyRunner implements Callable < Boolean > {
 
private int workerNumber ;
 
public int getNumber ( ) {
return workerNumber ;
}
 
public void setNumber ( int workerNumber ) {
this . workerNumber = workerNumber ;
}
 
public CrunchifyRunner ( int workerNumber ) {
this . workerNumber = workerNumber ;
setNumber ( workerNumber ) ;
}
 
SimpleDateFormat crunchifyFormatter = new SimpleDateFormat ( "dd-MMMMM-yyyy hh:mm:ss" ) ;
 
public Boolean call ( ) throws InterruptedException {
try {
if ( workerNumber == 4 ) {
 
// Sleep for 20 Seconds to generate long running thread.
Thread . sleep ( 20000 ) ;
} else {
Thread . sleep ( 50 ) ;
}
} catch ( InterruptedException ie ) {
log ( "\n" + crunchifyFormatter . format ( new Date ( ) ) + " crunchifyWorker task " + workerNumber + " interrupted." ) ;
log ( "\n=======> Basically once thread is timed out, it should be cancelled and interrupted. (timedout ==> cancelled ==> interrupted)" ) ;
}
 
// Thrown when a thread is waiting, sleeping, or otherwise occupied, and the thread is interrupted, either before or during the activity. Occasionally a
// method may wish to test whether the current thread has been interrupted, and if so, to immediately throw this exception.
return true ;
}
 
public void log ( String info ) {
System . out . println ( info ) ;
 
}
}

Schritt-2 Erstellen Sie die Klasse CrunchifyJavaTaskTimeout.java

CrunchifyJavaTaskTimeout.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
package crunchify . java . tutorials ;
 
import java . text . SimpleDateFormat ;
import java . util . ArrayList ;
import java . util . Collection ;
import java . util . Date ;
import java . util . List ;
import java . util . concurrent . Callable ;
import java . util . concurrent . CompletionService ;
import java . util . concurrent . ExecutionException ;
import java . util . concurrent . ExecutorCompletionService ;
import java . util . concurrent . Executors ;
import java . util . concurrent . Future ;
import java . util . concurrent . TimeUnit ;
 
/**
* @author Crunchify.com
* Version: 1.0.2
*
*/
 
public class CrunchifyJavaTaskTimeout {
 
@ SuppressWarnings ( { "rawtypes" , "unchecked" } )
 
public static void main ( final String [ ] args ) {
 
// Creates an ExecutorCompletionService using the supplied executor for base task execution and a LinkedBlockingQueue as a completion queue.
CompletionService < Boolean > crunchifyService = new ExecutorCompletionService < Boolean > ( Executors . newFixedThreadPool ( 1 ) ) ;
 
Collection < CrunchifyRunner > crunchifyThreads = new ArrayList < CrunchifyRunner > ( 50 ) ;
 
crunchifyThreads . add ( new CrunchifyRunner ( 1 ) ) ;
crunchifyThreads . add ( new CrunchifyRunner ( 2 ) ) ;
crunchifyThreads . add ( new CrunchifyRunner ( 3 ) ) ;
crunchifyThreads . add ( new CrunchifyRunner ( 4 ) ) ;
 
SimpleDateFormat crunchifyFormatter = new SimpleDateFormat ( "dd-MMMMM-yyyy hh:mm:ss" ) ;
 
List < Future < Boolean > > crunchifyFutures = new ArrayList < Future < Boolean > > ( crunchifyThreads . size ( ) ) ;
try {
 
// Let's first add all tasks to future
for ( Callable crunchifyTask : crunchifyThreads ) {
 
crunchifyFutures . add ( crunchifyService . submit ( crunchifyTask ) ) ;
}
for ( int count = 1 ; count < = crunchifyFutures . size ( ) ; count ++ ) {
 
// Let's put Future timeout to 3 Seconds
Future < Boolean > crunchifyResult = crunchifyService . poll ( 3000 , TimeUnit . MILLISECONDS ) ;
if ( crunchifyResult == null ) {
 
log ( crunchifyFormatter . format ( new Date ( ) ) + "\n ==> crunchifyWorker task " + count + " timedout." ) ;
 
// So lets cancel the first futures we find that haven't completed
for ( Future crunchifyFuture : crunchifyFutures ) {
if ( crunchifyFuture . isDone ( ) ) {
continue ;
} else {
crunchifyFuture . cancel ( true ) ;
log ( " ==> crunchifyWorker task " + count + " cancelled." ) ;
break ;
}
}
continue ;
} else {
try {
if ( crunchifyResult . isDone ( ) && !crunchifyResult.isCancelled() && crunchifyResult.get()) {
log(crunchifyFormatter.format(new Date()) + " ==> crunchifyWorker task " + count + " completed.");
 
} else {
log ( crunchifyFormatter . format ( new Date ( ) ) + " ==> crunchifyWorker task failed" ) ;
}
} catch ( ExecutionException exception ) {
log ( exception . getMessage ( ) ) ;
}
}
}
} catch ( InterruptedException exception ) {
 
// Log exception message
log ( exception . getMessage ( ) ) ;
} finally {
 
// Cancel by interrupting any existing tasks currently running in Executor Service
for ( Future < Boolean > future : crunchifyFutures ) {
future . cancel ( true ) ;
}
}
log ( "\n=======> All tasks completed. Now long running thread 4 should be interrupted immediately after this." ) ;
System . exit ( 0 ) ;
}
 
private static void log ( String string ) {
System . out . println ( string ) ;
 
}
 
}

Schritt 3

Klicken Sie mit der rechten Maustaste auf CrunchifyJavaTaskTimeout.java und führen Sie es als Java-Anwendung aus.

Sie sehen unten das Ergebnis in der Eclipse-Konsole.

So beenden Sie den Java-Thread zur Laufzeit

1
2
3
4
5
6
7
8
9
10
11
12
27 - November - 2018 10 : 32 : 29 == > crunchifyWorker task 1 completed .
27 - November - 2018 10 : 32 : 29 == > crunchifyWorker task 2 completed .
27 - November - 2018 10 : 32 : 29 == > crunchifyWorker task 3 completed .
27 - November - 2018 10 : 32 : 32
== > crunchifyWorker task 4 timedout .
== > crunchifyWorker task 4 cancelled .
 
======= > All tasks completed . Now long running thread 4 should be interrupted immediately after this .
 
27 - November - 2018 10 : 32 : 32 crunchifyWorker task 4 interrupted .
 
======= > Basically once thread is timed out , it should be cancelled and interrupted . ( timedout == > cancelled == > interrupted )

Lassen Sie mich wissen, wenn Sie Fragen zu diesem Thema haben.