停止ExecutorService任务中的无限循环 导入java.util.array; 导入java.util.Iterator; 导入java.util.List; 导入java.util.concurrent.Callable; 导入java.util.concurrent.ExecutorService; 导入java.util.concurrent.Executors; 导入java.util.concurrent.Future; 导入java.util.concurrent.TimeUnit; 类任务实现可调用{ 公共字符串调用()引发异常{ 字符串s=“初始”; 试一试{ System.out.println(“已启动…”); /*对于(int i=0;i
Yes),您可以用停止ExecutorService任务中的无限循环 导入java.util.array; 导入java.util.Iterator; 导入java.util.List; 导入java.util.concurrent.Callable; 导入java.util.concurrent.ExecutorService; 导入java.util.concurrent.Executors; 导入java.util.concurrent.Future; 导入java.util.concurrent.TimeUnit; 类任务实现可调用{ 公共字符串调用()引发异常{ 字符串s=“初始”; 试一试{ System.out.println(“已启动…”); /*对于(int i=0;i,java,executorservice,Java,Executorservice,Yes),您可以用!Thread.currentThread().isInterrupted()替换标志(或逻辑上&&) 这样,当任务完成时,循环将终止 循环看起来像这样: import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; impor
!Thread.currentThread().isInterrupted()
替换标志(或逻辑上&&
)
这样,当任务完成时,循环将终止
循环看起来像这样:
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
class Task implements Callable<String> {
public String call() throws Exception {
String s = "initial";
try {
System.out.println("Started..");
/*for (int i=0;i<10000;i++) {
if (i % 2 == 0) {
System.out.println("Even");
}
}*/
boolean flag = true;
while(flag) {
}
System.out.println("Finished!");
s = "Done";
}
catch (RuntimeException e) {
s = "RuntimeException";
}
catch (Exception e) {
s = "Exception";
}
finally {
}
return s;
}
}
public class ExecutorServiceTest {
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newSingleThreadExecutor();
List<Future<String>> result = executor.invokeAll(Arrays.asList(new Task()), 5, TimeUnit.SECONDS);
executor.shutdown();
Iterator<Future<String>> iter = result.iterator();
while (iter.hasNext()) {
System.out.println("Came here");
Future<String> fut = iter.next();
System.out.println(fut.get());
}
}
}
while(!Thread.currentThread().isInterrupted() && flag) {
/* Do work. */
}
用法应该是这样的:
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
class Task implements Callable<String> {
public String call() throws Exception {
String s = "initial";
try {
System.out.println("Started..");
/*for (int i=0;i<10000;i++) {
if (i % 2 == 0) {
System.out.println("Even");
}
}*/
boolean flag = true;
while(flag) {
}
System.out.println("Finished!");
s = "Done";
}
catch (RuntimeException e) {
s = "RuntimeException";
}
catch (Exception e) {
s = "Exception";
}
finally {
}
return s;
}
}
public class ExecutorServiceTest {
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newSingleThreadExecutor();
List<Future<String>> result = executor.invokeAll(Arrays.asList(new Task()), 5, TimeUnit.SECONDS);
executor.shutdown();
Iterator<Future<String>> iter = result.iterator();
while (iter.hasNext()) {
System.out.println("Came here");
Future<String> fut = iter.next();
System.out.println(fut.get());
}
}
}
while(!Thread.currentThread().isInterrupted() && flag) {
/* Do work. */
}
ExecutorService executor=Executors.newSingleThreadExecutor();
Future task=executor.submit(新任务());
字符串str;
试一试{
str=task.get(5,TimeUnit.SECONDS);
}最后{
任务。取消(true);
}
考虑使用synchronized(this){this.wait()}
而不是sleep
内部call()
,然后当您在外部设置布尔标志时(可能直接或通过标志()
方法;通过直接访问确保您的标志变量是volatile
)调用task.notifyAll()
以唤醒休眠线程(确保任务对象是局部变量,而不是匿名的,这样您就可以对其调用方法,并使标志成为task
中的类属性)
这样也会更有效,因为循环不必要地浪费循环——确切的机制称为“保护块”(guarded block)。当您从等待中醒来时,测试flag变量以确保它已设置
编辑:更仔细地查看原始问题,并使用现有的代码和原则创建了一个示例(有多种方法可以剥除cat:)。请尝试此操作--此处的循环由于当前线程的中断状态而退出,由于超时已取消:
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> task = executor.submit(new Task());
String str;
try {
str = task.get(5, TimeUnit.SECONDS);
} finally {
task.cancel(true);
}
package;
导入java.util.array;
导入java.util.List;
导入java.util.concurrent.Callable;
导入java.util.concurrent.CancellationException;
导入java.util.concurrent.ExecutorService;
导入java.util.concurrent.Executors;
导入java.util.concurrent.Future;
导入java.util.concurrent.TimeUnit;
类任务实现可调用{
公共字符串调用()引发异常{
字符串s=“初始”;
System.out.println(“已启动…”);
对于(int i=0;i++){
如果(i%2==0){
System.out.println(“偶数”);
}
螺纹屈服强度();
如果(Thread.interrupted())中断;
}
System.out.println(“完成!”);
s=“完成”;
返回s;
}
}
公共类测试{
公共静态void main(字符串[]args)引发异常{
ExecutorService executor=Executors.newSingleThreadExecutor();
List result=executor.invokeAll(Arrays.asList(new Task()),1,TimeUnit.SECONDS);
executor.shutdown();
System.out.println(“来到这里”);
对于(未来f:结果){
试一试{
System.out.println(f.get());
}捕获(取消异常e){
e、 printStackTrace();
}
}
}
}