• 홈페이지
  • 조항
  • 일반적인
  • 런타임에 장기 실행 Java 스레드를 중지/종료하는 방법은 무엇입니까? 시간 초과 -> 취소됨 -> 중단된 상태

런타임에 장기 실행 Java 스레드를 중지/종료하는 방법은 무엇입니까? 시간 초과 -> 취소됨 -> 중단된 상태

게시 됨: 2021-07-17

완료하는 데 예상보다 오래 걸리는 Java 스레드를 종료하는 방법은 무엇입니까? 시간 초과 -> 취소됨 -> 중단된 상태

오래 실행되는 Java 스레드를 종료하는 방법을 궁금해 한 적이 있습니까? 아래 질문이 있습니까?

  • 일정 시간이 지나면 스레드를 종료/중지
  • Java에서 지정된 시간 제한 후 스레드 종료
  • 자바 스레드를 죽이는 방법
  • 예제를 사용하여 Java에서 스레드를 중지하는 방법
  • Java 코드 예제에서 스레드를 중지하는 방법
  • stop 메소드를 사용하지 않고 Java에서 스레드를 중지하는 방법

아래 질문 중 하나가 있으면 올바른 위치에 있습니다. 오늘 우리는 오래 실행되는 스레드를 종료하는 Java8 방법을 보여주는 간단한 예를 살펴보겠습니다.

논리란 무엇인가:

  1. CrunchifyJavaTaskTimeout.java 클래스 생성
  2. 스레드 풀 크기가 1개인 Java 스레드 실행기를 작성하십시오.
  3. 3초의 시간 초과로 CrunchifyRunner 개체의 4가지 향후 작업 생성
  4. CrunchifyRunner.java는 call() 메서드를 구현하는 간단한 클래스입니다.
    • futureTask = 4 경우 20 seconds 지연이 발생합니다.
  5. 미래가 3 seconds 에 도달하면 스레드가 여전히 실행 중인 경우 시간 초과 예외가 생성됩니다.
    • 시간이 초과되면 crunchifyFuture를 사용하여 작업을 취소해야 합니다. cancel( true ) ;
    • futureTask가 취소되면 InterruptedException 이 트리거됩니다(스레드가 대기 중이거나, 잠자거나, 다른 방식으로 점유되고 스레드가 활동 전이나 도중에 중단될 때 발생합니다. 때때로 메소드는 현재 스레드가 중단되었는지 테스트하기를 원할 수 있습니다. 그렇다면 이 예외를 즉시 throw합니다.)

시작하자:

1단계 CrunchifyRunner.java 클래스 생성

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 ) ;
 
}
}

2단계 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 ) ;
 
}
 
}

3단계

CrunchifyJavaTaskTimeout.java를 마우스 오른쪽 버튼으로 클릭하고 Java 애플리케이션으로 실행합니다.

Eclipse 콘솔에서 아래 결과를 볼 수 있습니다.

런타임에 Java 스레드를 중지하는 방법

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 )

이 주제에 대해 질문이 있으면 알려주십시오.