在ExecutorService中是否接受InterruptedException？
基础概念
ExecutorService 是 Java 并发包 java.util.concurrent 中的一个接口，用于管理和控制线程的执行。它提供了一种将任务提交给线程池执行的方式，从而简化了多线程编程。
InterruptedException 是 Java 中的一个异常，通常在一个线程正在等待、休眠或以其他方式占用时，如果它被中断，则会抛出此异常。
相关优势
ExecutorService 的优势包括：
- 线程管理：自动管理线程的生命周期，包括创建、执行和销毁。
- 任务调度：提供多种任务调度方式，如定时任务、周期性任务等。
- 资源控制：通过线程池大小控制并发线程数，避免资源耗尽。
类型
ExecutorService 接口有多种实现类，常见的包括：
ThreadPoolExecutor：基于线程池的实现。ScheduledThreadPoolExecutor：支持定时和周期性任务执行。
应用场景
ExecutorService 适用于以下场景：
- 并发任务处理：当需要同时处理多个任务时。
- 后台任务：如定时任务、日志处理等。
- Web 服务器：处理大量并发请求。
问题解答
在 ExecutorService 中，任务（通常是实现了 Runnable 或 Callable 接口的类）可以接受 InterruptedException。当一个线程在执行任务时被中断，它会抛出 InterruptedException，任务可以通过捕获这个异常来响应中断。
示例代码
import java.util.concurrent.*;
public class ExecutorServiceExample {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
Runnable task = () -> {
try {
System.out.println("Task started");
Thread.sleep(5000); // 模拟长时间运行的任务
System.out.println("Task completed");
} catch (InterruptedException e) {
System.out.println("Task interrupted");
Thread.currentThread().interrupt(); // 重新设置中断状态
}
};
executorService.submit(task);
// 中断任务
executorService.shutdownNow();
try {
executorService.awaitTermination(10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}参考链接
总结
ExecutorService 中的任务可以接受 InterruptedException，任务可以通过捕获这个异常来响应中断。捕获 InterruptedException 后，通常需要重新设置中断状态，以便上层代码能够检测到中断。
相关·内容
2回答
我有一个异步函数，它调用其他异步函数。在Java中，如何等待直到异步调用完成(包括其中的任何嵌套异步调用)。 我已经可以未来调用，但没有运气。 示例代码： void asyncMehodA(){ }
void asyncMethodB() {
asyncMehodA();
} 我用以下方式尝试了Future callable： final Callable<Void> callable1 = new Callable<Void>() {
@Override
public Void call() {
浏览 36提问于2019-04-01得票数 3
回答已采纳
见以下两个例子：
示例1
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newCachedThreadPool();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
//work
浏览 1提问于2020-10-08得票数 0
回答已采纳
我正在尝试一个java程序来理解Future的工作。
我写了下面的程序，它永远不会结束。如果我在Thread.sleep()中放置的值小于10，那么它对值>=10有效，但对值不起作用。
我理解导致问题的部分可能是future.get调用。
但是，在进一步的分析中，我尝试的是处理所有的异常，而不是让jvm处理它们。
例：
现在一切都结束了。
我做了进一步的检查，发现如果我抛出ExecutionException和InterruptedException并处理TimeoutException，它将再次正常工作。在这里奇怪的是，我不得不强制处理TimeoutException，
浏览 3提问于2021-03-18得票数 0
回答已采纳
在尝试从fixedThreadPool调用可调用列表时，我遇到了一个问题。虽然所有的可调用都将执行，但其中一些似乎同时被分派到不同的线程，因此它们实际上被调用了不止一次。请参见以下代码：
try {
ExecutorService es = Executors.newFixedThreadPool(Environment.nThreads);
es.invokeAll(Environment.jobPool);
es.shutdown();
} catch (InterruptedException e) {
e.printStackTrace();
}
浏览 1提问于2012-03-05得票数 0
我有一个启动4个线程的小程序，每个线程计数为偶数到20。我只在其中一个线程执行时休眠，但似乎所有其他线程都被阻塞，等待被阻塞的线程恢复。
为什么启用并行流处理会导致这样的行为？
public class Program {
static int first;
public static void main(String[] a) throws InterruptedException {
new Program().runTasks();
}
private void runTasks() thr
浏览 0提问于2015-05-05得票数 2
1回答
我需要在一个方法中正确地关闭两个Executor Service实例。
以下是我的简化代码：
ExecutorService executor1 = Executors.newSingleThreadExecutor();
ScheduledExecutorService executor2 = Executors.newSingleThreadScheduledExecutor();
// logic here
executor1.shutdown();
executor2.shutdown();
try {
if (!executor1.awaitTermination(1, Ti
浏览 2提问于2015-12-28得票数 3
回答已采纳
我正在尝试使用自定义对象创建一个新线程，然后从主线程调用这个自定义对象方法。其思想是主线程可以继续执行其他操作，而自定义对象则继续在第二个线程中工作：
public class Multithreading {
public static void main(String[] args) {
Multithreading mt = new Multithreading();
mt.multiTest();
}
public void multiTest() {
SomeObject someObject = new S
浏览 3提问于2018-04-25得票数 2
回答已采纳
我需要测试InterruptedException和ExecutionException，并为它们编写JUnits。
在这一点上请给我一些建议。我如何中断线程来复制场景。populateDataForm将启动新的线程并将其添加到期货列表中。
下面是我的示例代码：
class MyTest{
public populateData(){
Collection<Future<?>> futures = new LinkedList<Future<?>>();
DataSet ds = Helper.populateDataF
浏览 1提问于2013-06-19得票数 3
回答已采纳
类ThreadPoolExecutor中的Finalize方法如下所示。
protected void finalize() {
shutdown();
}
考虑下面的程序，其中线程永远不会终止。
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(new Runnable() {
@Override
public void run() {
try {
n
浏览 2提问于2012-09-22得票数 1
1回答
如何进行单元测试运行类？
、、、
考虑到这段代码
class ReportSenderRunnable implements Runnable {
@Override
public void run() {
executeTasks();
}
private void executeTasks() {
try {
runTask1();
} catch (final InterruptedException e) {
logError(ReportStatus.COMPRESSING, e.getMessage());
浏览 3提问于2015-04-15得票数 2
回答已采纳
我正在运行简单的thread，该方法如下所示
public run()
while(!stopFlag){
// print something Line 1
// print something Line 2
// print something Line 3
// print something Line 4
}
如果我在ExecutorService viz中运行这个线程
ExecutorService exs = Executors.newFixedThreadPool(5);
exs.execute(new MyThread));
我阻止了ExecutorSe
浏览 7提问于2017-05-16得票数 2
回答已采纳
3回答
我正在尝试一个用java实现多线程的例子。在Java Complete reference第7版中有一个关于多线程同步的例子。该示例运行良好。但是，当我稍微添加一行代码来创建同一个类的另一个线程时，这并不起作用。请告诉我为什么会发生这样的事情。下面给出了示例。下面的代码是生产者和消费者的典型例子。如果只有一个生产者，当我有两个生产者时，它工作得很好，那么它就会失败。它只是放到15，然后停下来。
class Q {
int n;
boolean valueSet = false;
synchronized int get() {
while (!val
浏览 1提问于2013-04-13得票数 0
2回答
我有这个小代码来测试Callable。但是，我发现编译器如何知道Lambda是接口可调用的还是可运行的，因为它们的函数中都没有任何参数。
然而，IntelliJ显示Lambda使用了可调用的代码。
public class App {
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.submit(()
浏览 0提问于2018-08-14得票数 9
回答已采纳
我试图掌握Java中的并发性，我编写了这个简单的代码来打印字母的字母：
public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
final ExecutorService threadPool = Executors.newFixedThreadPool(4);
final ExecutorCompletionService<Character> completionService = new Executor
浏览 1提问于2021-08-23得票数 1
回答已采纳
我在一个简单的Spring项目中学习ExecutorService。我知道ExecutorService使用submit方法提交任务，并且它将对每个任务使用不同的线程。我不明白新线程到底是从哪里开始的。我知道线程是使用start方法启动的。有人能解释一下在哪里调用start方法吗？
例如，这是我的代码：
try {
ExecutorService executorService = Executors.newFixedThreadPool(3);
Future<Accounts> accountFuture =
executorService
浏览 7提问于2022-10-16得票数 -1
我使用ExecutorService在不同的线程中运行许多任务。有时，在线程池中等待太多可运行的实例可能会导致内存不足问题。
我试着写一个阻塞作业执行器来解决这个问题。有什么正式的解决办法吗？
例如：
BlockingJobExecutor executor = new BlockingJobExecutor(3);
for (int i = 0; i < 1000; i++) {
executor.addJob(new Runnable() {
@Override
public void run() {
浏览 4提问于2013-08-08得票数 7
回答已采纳
我使用PriorityBlockingQueue实现了我的ThreadPoolExecutor，如下例所示：
并写了一个测试：
PriorityExecutor executorService = (PriorityExecutor) PriorityExecutor.newFixedThreadPool(16);
executorService.submit(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(100
浏览 0提问于2013-05-30得票数 5
回答已采纳
这可能是个老问题。我对Jboss环境中的ExecutorService工作感到困惑。我使用了一些示例代码，在这里，我使用ExecutorService提交任务，在完成所有操作之后，我将关闭执行器。
我面临的问题是在提交了一个请求之后，我得到了下面的例外为后续的请求。导致的java.util.concurrent.RejectedExecutionException:任务java.util.concurrent.FutureTask@518ad6a2从java.util.concurrent.ThreadPoolExecutor@72114f80Shutting向下拒绝，池大小= 1，活动线程=
浏览 2提问于2016-01-29得票数 2
回答已采纳
1回答
如何使回调在“主线程”中执行？
@Test
void threadTest() throws InterruptedException {
System.out.println("main thread:" + Thread.currentThread());
new Thread(new AsyncTask(this::callback)).start();
Thread.sleep(1100);
}
private void callback() {
System.out.println("callback executed
浏览 2提问于2022-08-23得票数 0
3回答
到目前为止，这段代码在测试中似乎运行良好。不过，我是多线程方面的新手，我想知道这段代码是否理想，因为我知道有很多关于并发的"donts“。
是否有更好的方法在单个线程上为排队的Runnable创建一个执行器？这是我第一次做，所以我倾向于相信有更好的东西。
public class ExplosionExecutor{
private static List<Runnable> queue= new ArrayList<Runnable>();
private static Thread thread= new Thread(new Runnable() {
浏览 3提问于2014-01-03得票数 0
回答已采纳
1回答
我有三个可以并行运行的web服务调用。因此，我使用由3个线程组成的固定池来运行它们。
现在，我想再处理几个web服务调用，它们可以并行运行，但只能在前三个调用被处理之后才能运行。
如何批量处理？我希望批处理中的那些并行运行。并且每个批处理仅在前一批处理完成后才运行。
到目前为止，我只使用了三个服务。我如何批量处理它们并开始使用另外两个服务？
ExecutorService peopleDataTaskExecutor = Executors.newFixedThreadPool(3);
Future<Collection<PeopleInterface>> t
浏览 1提问于2016-09-08得票数 4
1回答
输入代码hereSuppose，我有两个线程，Thread1和Thread2，以及hashmap下面的空值。现在，我想用正在执行print语句的相应线程打印HashMap的键，而不再次打印它。
输入Hashmap：
"Hello“null
“客户”空
“值”空
“再见”空
输出：
“再见”：由Thread1印刷
“你好”：“由Thread2印刷”
“价值”：“由Thread2印刷”
“客户”：“由Thread1印刷”
到目前为止，我还不能用下面的代码打印。
import java.util.ArrayList;
import java.util.Collection;
浏览 3提问于2017-09-02得票数 0
在main方法中，使用java1.5执行器服务机制启动子线程。如何让主线程等待到子线程完成？
public class MainClass {
public static void main(String[] args) {
ExecutorService executorService=null;
try {
executorService=Executors.newFixedThreadPool(1);
executorService.execute(new TestThread());
浏览 4提问于2011-09-10得票数 6
我正在尝试学习java的并发API。下面是一个示例程序。
class WaitTest {
public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
ExecutorService executorService = null;
try {
executorService = Executors.newSingleThreadExecutor();
浏览 2提问于2018-12-14得票数 1
我正在使用ExecutorService，并提交了2个Callables。
你能告诉我使用ExecutorService.awaitTermination和使用Future.get()有什么区别吗？
我不希望线程无限期地运行，而且每个Future的异常都不应该影响其他线程的Future。
ExecutorService executor = Executors.newFixedThreadPool(2);
Future<MyObject1> obj1 = null;
if (true) {
task1 = executor.submit(
浏览 31提问于2017-05-09得票数 0
1回答
我需要创建两个类，Class Player和Class Referee，implement Runnable接口(基本上是创建线程)。
线程执行的顺序如下
裁判员1或2，裁判1或2，等等。
这是我想出的解决方案，但是，秩序似乎并没有发生。甚至在裁判完成检查之前，球员们就会继续比赛。
public class a {
public static synchronized void main(String[] args) throws InterruptedException {
ready = false;
finish = false;
浏览 2提问于2015-12-04得票数 0
回答已采纳
我想使用Executor接口(使用可调用的)来启动线程(让我们称它为可调用线程)，它将执行使用阻塞方法的工作。这意味着当主线程调用Future.cancel(true) (调用Thread.interrupt())时，可调用线程可以抛出一个Thread.interrupt。
我还希望我的可调用线程在使用代码取消部分中的其他阻塞方法()中断时正确终止。
在实现此过程中，我经历了以下行为:当我调用Future.cancel(true)方法时，可调用线程将被正确地通知中断，但是如果主线程立即使用等待终止，则可调用线程是在调用任何阻塞方法时杀死的某种。
下面的JUnit 5片段说明了这个问题。如果主线
浏览 2提问于2019-01-22得票数 6
回答已采纳
CompletableFuture.supplyAsync(
() -> {
transporter.write(req);
//here take the value from a blocking queue,will throw a interruptedException
return responseQueue.take();
}, executorService);
处理interruptedException的常用方法是再次中断或直接抛出interruptedException，但两者都无法工作。有人有这个主意吗？
浏览 3提问于2014-04-20得票数 18
回答已采纳
2回答
我试着用executorService.shutdown();结束一个executorService.shutdown();，如果这不起作用，就用executorService.shutdown();。问题是，executorService无法停止，程序仍在运行。
下面是我的类，它将启动一个WatchService来查看目录中的更改：
public class FileWatcher {
/**
* This Class starts a WatchService to get changes on a specific folder.
*/
Path d
浏览 3提问于2014-01-19得票数 0
回答已采纳
我在关注
在这个例子中，可以创建一个线程池，它将执行3个不同的任务。
但是，我只想创建一个任务，它由n个线程执行。
int numberOfThreads = 2;
ExecutorService executorService = Executors.newFixedThreadPool(numberOfThreads);
Runnable task1 = () -> {
System.out.println("Executing Task1 inside : " +
Thread.currentThread().getName());
try {
浏览 16提问于2019-07-11得票数 0
回答已采纳
我正在寻找一种在java中执行批任务的方法。这个想法是基于线程池创建一个ExecutorService，这将允许我在来自main线程的不同线程之间传播一组Callable。该类应该提供一个waitForCompletion方法，该方法将使main线程处于休眠状态，直到执行所有任务为止。然后应该唤醒main线程，它将执行一些操作并重新提交一组任务。
这个过程将重复多次，所以我想使用ExecutorService.shutdown，因为这需要创建多个ExecutorService实例。
目前，我已经使用AtomicInteger和Lock/Condition实现了它
public class Ba
浏览 5提问于2012-04-24得票数 6
回答已采纳
我正在尝试编写一个简单的函数，它将多个消息长时间轮询到下游依赖项，而不会耗尽它，并且仅当所有消息都成功时才存在。 我想出了一种方法，将每个消息轮询封装到一个callable中，并使用ExecutorService提交一个callable列表。 public void poll(final List<Long> messageIdList) {
ExecutorService executorService = Executors.newFixedThreadPool(messageIdList.size());
List<Messag
浏览 12提问于2019-09-12得票数 0
2回答
我有一个信号量，限制用户一次下载n个文件。每个文件都在一个单独的线程中下载。
编辑：修改了示例，以便正确发布
import java.util.concurrent.Semaphore;
public void downloadFile() {
Thread downloadThread = new Thread() {
boolean bSemaphoreAcquired = false;
public void run() {
try {
semaphore.acquire();
浏览 1提问于2009-08-04得票数 2
回答已采纳
在Java5中，ExecutorService接口声明方法：
<T> List<Future<T>> invokeAll(Collection<Callable<T>> tasks)
throws InterruptedException;
而用Java6编写的Guava11.0.2应该与Java5兼容，它在ListeningExecutorService中将其覆盖为：
<T> List<Future<T>> invokeAll(Collection<? extends Callab
浏览 17提问于2012-04-20得票数 2
回答已采纳
1回答
有许多类似的问题，但没有解决办法对我有效。
我有一个可调用的，需要运行一定时间。在调用方法执行期间，它必须在while条件下定期执行一些检查，以检查是否必须继续运行。我还希望能够从外部停止可调用(API调用)。
下面的代码是一个简化的版本，但它也有同样的问题：
当可调用的返回时，线程处于等待状态。我如何杀死这个线程？
public class MyCallable implements Callable<Foo> {
private AtomicBoolean stop = new AtomicBoolean(false);
@Override
publi
浏览 0提问于2019-10-13得票数 0
回答已采纳
我了解到，在捕获InterruptedException之后将Thread.interrupter()标志重新设置为true是一种好的做法。 但是，当我调用executorService.invokeAll()并通过捕获InterruptedException将try子句放在它周围时，Thread.currentThread().interrupt()会正确地标记中断的线程或控制器/运行器的主线程吗？ public class Controller {
public void run() {
final List<Task> tasks = reque
浏览 10提问于2019-06-05得票数 0
回答已采纳
1回答
下面是一段简单的代码，它只尝试对字符串类型使用相同的executorService，这并不能解决my problem在一起处理多个字符串的问题，除非它们是同一类型的，否则线程必须等待前一个字符串被处理。
另外，请建议我是否可以使用阻塞队列来实现这一点，以及如何实现？
我可以想到的另一种方法，但无法实现--将所有选择了一种类型等待在队列中的线程放到队列中，这样就可以按顺序处理它们。同时，其他类型也会被其他线程捕获。
类型A <-线程1<-线程2<-线程3<-线程8
B型<-线程4<-线程5
C型<-线程9.诸若此类。
import java.ut
浏览 3提问于2016-06-02得票数 0
javadoc说invokeAll(Collection<> callables)抛出
InterruptedException -如果在等待时中断，则取消未完成的任务。
但是没有任何文件可以说明为什么通话会被中断。我的程序是这样做的-但很少，我不能写一个测试会导致它发生。
我使用的是一个参数方法，没有超时。
public class ParallelUtil<T> {
public interface Task<T> {
public void execute(T data) throws Exception;
}
浏览 0提问于2017-08-30得票数 2
回答已采纳
我试图为我们的Java应用程序创建10个线程，并始终保持它们的活力。这10个线程应该一直处于活动状态，并运行我分配给它们的任务。我试图分配的任务是文件下载、报告下载和PDF下载。
我试着让他们活下去，让他们一直睡觉，并在给他们分配新任务时打断他们。但是，这些文件生成是基于我们系统中不同的参数，因此我无法在InterruptedException异常捕获块中定义文件生成逻辑。我很好奇是否有一种方法可以在不扩展线程或实现可运行接口的类中中断线程并为它们分配不同的任务(函数)？
我创建了10个一直处于休眠状态的线程，并将它们添加到一个公共静态数组中。
for (int i = 0; i < N
浏览 3提问于2021-11-23得票数 1
回答已采纳
我想在后台执行一些有时间限制的工作。问题是，我不想阻塞主线程。
朴素的实现是拥有两个executor服务。一个用于调度/超时，另一个负责完成工作。
final ExecutorService backgroundExecutor = Executors.newSingleThreadExecutor();
final ExecutorService workerExecutor = Executors.newCachedThreadExecutor();
backgroundExecutor.execute(new Runnable() {
public void run() {
浏览 0提问于2012-04-26得票数 4
2回答
我试图理解countDownLatch和我有这个程序，但我不知道为什么我的程序不返回和没有完成。
package countDownLatches;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Processor implements Runnable {
CountDownLatch latch;
public Processor(CountDow
浏览 2提问于2014-03-16得票数 1
回答已采纳
1回答
我想让我的控制器(Spring )并行处理请求。我在下面使用@Callable，它不起作用，因为下一个请求是在第一个请求完成后处理的(返回视图)。
@RequestMapping(method = RequestMethod.GET)
public Callable<String> helloWorld(final Model model) throws InterruptedException {
return new Callable<String>() {
@Override
public String call() thr
浏览 0提问于2013-10-13得票数 1
回答已采纳
我正在比较CompletableFuture.supplyAsync()在以下两种情况下的行为:我设置了一个自定义ExecutorService，或者我希望我的供应商由默认的执行器(如果没有指定)执行，即ForkJoinPool.commonPool()
让我们看看不同之处：
public class MainApplication {
public static void main(final String[] args) throws ExecutionException, InterruptedException {
Supplier<String> actio
浏览 1提问于2019-01-04得票数 2
回答已采纳
3回答
当我使用ExecutorService进行异步调用时，它返回Future Object。根据它返回的布尔值，我必须记录异步调用的状态。 但是当我试图从将来的对象调用get方法时，它阻塞了主线程的执行。 是否有可能解除主线程执行的阻塞？ public class FutureExample {
static HystrixCommand<Boolean> hystrixCommand;
public FutureExample(HystrixCommand<Boolean> hystrixCommand){
FutureExample
浏览 6提问于2019-04-11得票数 1
回答已采纳
我正在使用带有fixedThreadPool的ExecutorService。我通过实现Runnable接口来创建线程。在run()方法中，我调用了一个耗时的函数(现在假设是Thread.sleep() )，最后将一个元素添加到线程安全的CopyOnWriteArrayList中。我在for循环中提交线程。在for循环结束时，我关闭了ExecutorService并等待终止。
然而，列表中元素的数量并不等同于循环迭代的数量。我在并发思维中的错误在哪里？
以下是此问题的代码示例：
public class TestProgram {
public static void main(St
浏览 0提问于2014-12-20得票数 0
我希望做到这一点：
在我的应用程序中，我将有一个单独的线程(生产者)，它将从用户输入(用户希望爬行的目录)进行一些处理，并将该目录中所有文件夹的名称添加到一个名为A的linkedBlockingQueue中。同时，当生产者添加到A中时，多个使用者线程(例如2 )将取出A中的文件夹名。每个使用者线程将一次取出一个对象，处理它并放入另一个名为B的priorityBlockingQueue中。
我现在对线程有异议，我现在所做的是：
主要：
Thread[] workerThreads = new Thread[numOfThreads];
for (int i = 0; i < numOfT
浏览 3提问于2014-12-02得票数 0
回答已采纳
1回答
我正在实施一个标准的生产者-消费者计划，这样生产者停止生产200产品后。为了表明这一点，生产者将-1放入BlockingQueue变量，否则该变量总是包含正整数。我的消费者实现如下：
public class Consumer implements Runnable{
private BlockingQueue<Integer> queue;
private AtomicBoolean isProducerClosed = new AtomicBoolean(false);
public Consumer(BlockingQueue<Integer> queue) {
浏览 1提问于2018-04-09得票数 0
回答已采纳
我正在开发一个可以从不同URL检索文件的应用程序。
有一个包含要下载的目标的TreeSet。这是在一个循环中处理的，每个项目都用一个ExecutorService调用。下面是一些代码：
private void retrieveDataFiles() {
if (this.urlsToRetrieve.size() > 0) {
System.out.println("Target URLs to retrieve: " + this.urlsToRetrieve.size());
ExecutorService executorP
浏览 3提问于2012-10-31得票数 1
回答已采纳
1回答
我有一个web服务，它被20多个发送数据的服务器连续访问。我曾经使用过activeMQ，其中数据被排队了一段时间，然后使用异步任务，该数据被要求。
我的异步任务线程类如下所示。
public class myConsumer {
public void asyncConsumer() throws InterruptedException, ExecutionException{
final MyReceiver receiver = new MyReceiver();
final ExecutorService executorService
浏览 2提问于2015-09-10得票数 0
在我的游戏中，我将实现一个函数，该函数线性地将变量的值从100改为0，时间为5秒。这个功能必须通过玩家触摸一个按钮来启动。
首先，我只想通过一个带有for循环的TimeUnit.MILLISECONDS.sleep()和其中的值递减来完成这个任务：
for (int i = 0; i <= 100; i++) {
decrementBatteryLevel();
try {
TimeUnit.MILLISECONDS.sleep(50);
} catch (InterruptedException e) {
e.printStack
浏览 0提问于2019-02-11得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
