如何从线程向ExecutorService提交Callable
当需要从线程向 ExecutorService 提交 Callable 时，可以按照以下步骤进行操作：
- 创建一个 ExecutorService 对象，例如：
ExecutorService executor = Executors.newFixedThreadPool(10);- 创建一个 Callable 对象，例如：
Callable<String> callable = () -> "Hello, World!";- 将 Callable 对象提交给 ExecutorService，例如：
executor.submit(callable);在提交 Callable 对象时，需要确保 Callable 对象实现了 Callable 接口，并且提供了正确的返回值。
- 等待 Callable 对象完成执行，例如：
executor.shutdown();在等待 Callable 对象完成执行时，需要调用 shutdown() 方法来关闭 ExecutorService，以避免资源泄露。
总的来说，从线程向 ExecutorService 提交 Callable 的过程非常简单，只需要创建一个 Callable 对象并将其提交给 ExecutorService 即可。需要注意的是，在提交 Callable 对象时，需要确保 Callable 对象实现了 Callable 接口，并且提供了正确的返回值。
相关·内容
我有一个关于使用单线程执行器的问题。由于它重用相同的线程，这是否意味着如果我在一个提交调用中修改对象状态，我是否可以假设在随后的submit调用中对该对象状态的另一个修改是线程安全的？让我举个玩具例子..。
public class Main {
public static void main(String[] args) throws Exception {
final A a = new Main().new A();
ExecutorService executor = Executors.newSingleThreadExecutor();
浏览 3提问于2014-02-23得票数 5
回答已采纳
TLDR:我想同时提交两个可调用的表，但超时时间不同
在不同的超时情况下，同时运行两个invokeAll()命令，是否有一种方法或最佳选择？
除封锁外：
ExecutorService executorService1 = Executors.newFixedThreadPool(2);
ExecutorService executorService2 = Executors.newFixedThreadPool(2);
List<Callable<String>> callableTasks1;
List<Callable<String>>
浏览 10提问于2022-10-04得票数 1
回答已采纳
2回答
我遇到问题的代码是：
Executor executor = (Executor) callList;
List<ProgState> newProgList = executor.invokeAll(callList).stream()
.map(future -> {try {return future.get();} catch(Exception e){e.printStackTrace();}})
.filter(p -> p!=null).collect(Collectors.toList());
浏览 5提问于2016-01-02得票数 0
回答已采纳
我正在使用Java ExecutorService (ThreadPool)来执行任务&更新UI，而特定的活动在前台(可见)。
问题:我想要的是当用户切换到另一个活动时，我希望停止/取消所有任务(无论是排队还是正在运行)。为此，我必须在通过调用ExecutorService ()检查未来对象状态后，对ExecutorService提交方法返回的未来对象使用isDone关机/快门现在方法或取消(True)。这将将中断的相应线程标志设置为TRUE，必须检查可调用实现中的(Thread.currentThread.isInterrupted())，以确定是否中断，退出任务/线程。问题是我是调
浏览 1提问于2017-07-29得票数 0
回答已采纳
我正在使用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
Scheduler通过新的单线程从服务器获取配置。但是，即使调度程序正在执行config()以从服务器获取配置，应用程序也会继续执行。
App{
XXXX;
XXXX;
try{
scheduler()
} catch(Exception e){
}
public void scheduler(){
ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
Callable<Void> callable = n
浏览 0提问于2018-01-09得票数 1
1回答
因此，在Java并发中，有一个任务的概念，它实际上是任何实现Runnable或Callable的任务(更具体地说，该接口的被覆盖的run()或call()方法)。
我很难理解以下之间的关系：
ExecutorService使用的底层并发工作队列或列表结构A任务(Runnable/Callable)；以及提交任务的Runnable ExecutorService；以及
我相信这种关系有以下几点：
开发人员You必须选择哪种ExecutorService和工作结构最适合手头的任务----使用要使用的底层结构(例如，ArrayBlockingQueue)初始化ExecutorService (比方说
浏览 1提问于2012-05-02得票数 1
回答已采纳
2回答
class A{
final B;
B.compute(); // Does executing this line create a new thread since this returns
// a future and the entire function is executed by the same thread ?
}
class B{
Future<Void> compute(){
C obj = factoryOfC.getC();
ListenableFuture<Void&
浏览 1提问于2014-02-20得票数 0
我有一个在套接字连接上创建新线程的应用程序。我想从这个线程提交一个Callable到一个ExecutorService。Callable需要通过命令行参数执行程序，所以我不想通过连接线程来执行。
问题是，我不知道如何将Callable提交给一个设置了线程数的ExecutorService。
我曾经考虑过使用单例并编写一个submit方法来将我的Callable提交给ExecutorService实例，但由于不熟悉这个接口，我不确定这样做是否合理。
非常感谢您的帮助，谢谢。
浏览 0提问于2012-04-24得票数 0
回答已采纳
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回答
如何同时调用多个数据库上的查询并等待它们的结果返回？
设置
我使用JAX和JBoss 7来提供web服务。我的服务调用多个数据库上的查询，组合它们的结果并将所有结果返回给调用者。
我到目前为止做了什么，
我有一个正常工作的客户机和服务器(只是服务器没有从数据库中检索任何结果，但我会再讲一遍)。在代码的init方法中，我创建了一个重用的ExecutorService，并向其提交Callable(执行查询并从数据库返回结果)。这些Callable执行数据库查询并返回结果。
问题
我的Future返回null (我想我没有犯任何其他错误)。除此之外，我还在某个地方读到，您不应该在部署在Ex
浏览 0提问于2013-06-12得票数 0
回答已采纳
1回答
我有这样一堂课
import java.util.concurrent.*;
public class TestClass<V> {
private final ConcurrentMap<String, Future<V>> requests;
private final ExecutorService executorService;
public TestClass(final ExecutorService executorService) {
this.executorService = executorS
浏览 2提问于2017-10-23得票数 1
回答已采纳
有两种方法来提交和轮询结果。
FutureTask futureTask = new FutureTask<String>(callable);
使用Callable和Future的结合，在ExecutorService上提交。使用future.get()检索结果。
未来=service.submit(可调用)；
使用FutureTask。这将包装Callable，然后使用FutureTask检索结果。
任务(service.execute)；
使用FutureTask比使用Callable +未来组合有什么优势？
浏览 5提问于2015-06-22得票数 27
2回答
有10个线程，我有15个任务。现在，我已经将所有这些任务提交给这些线程。我需要将所有这些线程输出到一个我没有成功的文件中。
我是通过运行所有线程来获得输出的。
ThreadPool.java (创建线程池并将所有任务添加到阻塞队列并提交)
public class ThreadPool {
ExecutorService execService = null;
BlockingQueue<Callable<String[]>> tasks = null;
BlockingQueue<String> queue = null;
浏览 0提问于2013-06-09得票数 3
ExecutorService executorService = Executors.newSingleThreadExecutor();
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 1";
}
});
call
浏览 0提问于2015-06-20得票数 9
回答已采纳
2回答
我正在尝试使用Future和Callable将dfs递归方法转换为并行方法，以提高效率。但是不确定怎么做才对。代码如下：
public MyResult compute(MyTree tree, int depth, ExecutorService exec) {
if (depth >= 3) {
Callable<MyResult> callable = new Callable<MyResult>() {
@Override
public MyResult call() throws E
浏览 1提问于2012-05-30得票数 1
3回答
我尝试使用Java语言的FutureTask、Future、Runnable、Callable和ExecutorService类型。
构建这些构建块的最佳实践是什么？
假设我有多个FutureTask，并且我想按顺序执行它们。
当然，我可以创建另一个FutureTask，它按顺序提交/等待每个子任务的结果，但我希望避免阻塞调用。
另一种选择是让这些子任务在完成时调用回调，并在回调中调度下一个任务。但是走这条路，我如何创建一个合适的外部FutureTask对象，它也可以处理子任务中的异常，而不会产生太多的样板？
我是不是漏掉了什么？
浏览 2提问于2013-02-05得票数 6
回答已采纳
我有大量的任务需要用multithreading执行。
我使用ExecutorService提交了大量的Callable objects，每个Callable object都包含一些执行所需的resource。
问题
这些任务如此之多，以至于提交给ExecutorService的ExecutorService占用了太多内存，heap就耗尽了。
我想知道，JVM什么时候为这些Callable objects释放空间？
它是否在任务完成后立即执行此操作，以及如何管理用于ExecutorService的内存？
我想控制提交到ExecutorService，例如，当内存不够时，然后阻止提交使用一些任务
浏览 1提问于2012-03-01得票数 11
我有一个关于ExecutorService如何在Java中工作的基本问题。
很难看出简单地创建Threads来并行执行某些任务和将每个任务分配给ThreadPool之间的区别。
ExecutorService的使用看起来也非常简单和高效，所以我想知道为什么我们没有一直使用它。
这仅仅是一种比另一种方式更快地执行其任务的问题吗？
这里有两个非常简单的例子来说明这两种方法之间的区别：
使用执行器服务的：Hello (任务)
static class HelloTask implements Runnable {
String msg;
public HelloTask(Strin
浏览 0提问于2014-11-14得票数 26
回答已采纳
2回答
注:这与终止工作线程无关。这是关于正常终止的后果。
我在EDT中调用了execute，所以这就产生了一个“工作线程”。
我在Callable中调用Callable，并将其提交给ExecutorService，特别是ThreadPoolExecutor。
任务结束OK (即worker.get()返回一个结果，Callable也结束OK)。
我在Executor Service：方法上调用Executor Service：方法通常终止。
在此之后，当我检查线程时，就会出现这个难题。这是在单元测试的上下文中，我基本上想要消除在上一次测试期间开始的所有活动。
我列出了所有线程，除了测试开始前存在的各
浏览 4提问于2016-02-22得票数 3
回答已采纳
假设我计划在我的整个应用程序中使用一个executorservice，我发送新的runnable或callable来执行/提交，并且我忽略了在执行/提交之后立即关闭。我只想将我的“任务”抛给executorservice，让它处理并执行它们，并给出它的资源(它有多少可用的线程，如果需要的话，他可以创建多少线程，然后相应地对这些任务进行排队)。
根据你在安卓应用程序中使用ExecutorService的经验，并考虑到应用程序状态的变化，如果我不想通过这样做来不断关闭并重新创建executorservice：
executor = Executors.newCachedThreadPool
浏览 0提问于2013-05-01得票数 13
回答已采纳
1回答
在这段代码中，我使用两个线程处理两个任务。任务完成后，ExecutorService将被关闭。然后继续处理下一对“sku”和“inputText”。将再次创建两个线程来处理这两个任务和关机。它以这种方式继续，直到所有输入都被处理。
这是在本地方法中使用多个线程的一种正常方式吗？我担心在方法中经常创建和关闭ExecutorService局部变量可能不太好。
// defined as an instance variable
ExecutorService executorService = Executors.newFixedThreadPool(2);
public Extrac
浏览 0提问于2018-05-19得票数 2
回答已采纳
1回答
我想实现迭代深化(增量树构建)。这是我要问的代码的一部分：
ExecutorService executorService = Executors.newSingleThreadExecutor();
Set<Callable<Integer>> callables = new HashSet<Callable<Integer>>();
callables.add(new Callable<Integer>() {
public Integer call()
浏览 1提问于2013-10-26得票数 0
2回答
假设我有一个来自Executor静态工厂方法的ExecutorService实例。
如果我提交一个Callable，其中RetVal不是来自某个线程的线程安全的本地实例化对象，那么当我从同一个线程获取()它时，我需要担心RetVals的完整性吗？人们说局部变量是线程安全的，但我不确定当你返回一个本地实例化的对象并从其他线程接收它时，它是否适用。
下面是一个与我的情况类似的例子：
ExecutorService executor = Executors.newFixedThreadPool(5);
Future<List<String>> fut = executor.s
浏览 0提问于2020-01-08得票数 1
2回答
我有一个web应用程序，我可以从它开始各自的测试过程，它在另一个Java应用程序中。我使用套接字编程来实现Web应用程序和Java应用程序之间的通信。
当我从web应用程序请求特定的进程时，Java app的SocketServer就会听到请求并启动一个线程来测试进程。测试过程将初始化FirefoxDriver并启动浏览器，并进行进一步的测试过程。
我的问题是，当我请求另一个具有不同进程名称的进程时，它再次创建第二个线程并启动firefox浏览器，但这次它没有考虑我的第二个进程，它开始执行与第一线程相同的进程。
我不知道如何do...For每个进程，我创建了一个新的线程，但它将进一步做相同的进
浏览 4提问于2012-10-11得票数 2
回答已采纳
3回答
我是Java新手，谁能解释一下哪种方法在下面的给定代码中调用了调用方法，还可以帮助我理解给定代码的代码执行路径：
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
浏览 0提问于2014-04-09得票数 0
回答已采纳
既然使用ExecutorService可以submit一个Callable任务并返回一个Future，为什么需要使用FutureTask来包装Callable任务并使用execute方法呢？我觉得他们都在做同样的事情。
浏览 0提问于2011-02-10得票数 54
回答已采纳
我正在尝试实现一个函数，在这个函数中，可调用在规定的时间内完成，或者操作超时。我本来希望ExecutorService.awaitTermination()会这样做，但惊讶地发现它没有这样做。代码如下。运行永远不会结束。
public class Counter implements Callable<Void> {
public static void main(String[] args) throws InterruptedException {
final Map<String, Counter> map = new HashMap&l
浏览 6提问于2016-09-14得票数 1
回答已采纳
4回答
在B类中，我如何知道线程的任务已经完成？在after属性中，一些worker正在运行。在B类中，我需要知道worker是否完成了？
public class A implements InitializingBean{
public void method1(){
...
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.print("test after properties set");
浏览 0提问于2015-08-01得票数 5
我正在寻找一种在java中执行批任务的方法。这个想法是基于线程池创建一个ExecutorService，这将允许我在来自main线程的不同线程之间传播一组Callable。该类应该提供一个waitForCompletion方法，该方法将使main线程处于休眠状态，直到执行所有任务为止。然后应该唤醒main线程，它将执行一些操作并重新提交一组任务。
这个过程将重复多次，所以我想使用ExecutorService.shutdown，因为这需要创建多个ExecutorService实例。
目前，我已经使用AtomicInteger和Lock/Condition实现了它
public class Ba
浏览 5提问于2012-04-24得票数 6
回答已采纳
2回答
我正在使用ExecutorService运行一些可调用的线程。线程在提交到ExecutorService之前使用数据进行初始化。
在处理Future.get()抛出的异常时，我想用原始数据记录一条消息。可以从Future对象返回到创建它的原始线程吗？
伪代码：
void run(List<Data> dataList) {
List<Future<Foo>> results = new ArrayList<Future<Foo>>();
for (Data data : dataList) {
Call
浏览 1提问于2013-05-25得票数 1
回答已采纳
我有一个线程池执行器
private ExecutorService exec=Executors.newCachedThreadPool();
我有一节课
class MyCallable implements Callable<String>{
private ReentrantLock lock=new ReentrantLock();
private Condition cond=lock.newCondition();
public String call(){
System.out.println("TEST!!);
浏览 1提问于2015-05-27得票数 0
有没有更好的方法来做这件事？我宁愿使用j.u.c的现有框架，而不是使用我自己的框架。
请看"run“方法。
我需要重新提交的Callable尽快从未来获得的结果。我使用这个单独的Runnable Thread，就是为了做到这一点，如下所示。
尽管这应该被编译，但它显然不是一段有效的代码。
public class ResubmitOnCompletion implements Runnable {
private CompletionService<DeviceData> completionService;
private ConcurrentHash
浏览 0提问于2011-07-12得票数 1
回答已采纳
我正在使用ExecutorCompletionService提交一些任务。然后我想等待最大值，比如5秒，然后停止处理。
ExecutorService executorService = Executors.newFixedThreadPool(10);
CompletionService<String> completionService = new ExecutorCompletionService<String>(
executorService);
List<Callable<String>> calla
浏览 2提问于2015-09-27得票数 1
以下是两种选择
1)创建一个可调用的，并多次提交
Callable<String> callable = new MyCallable();
for(int i=0; i< 100; i++){
Future<String> future = executor.submit(callable);
list.add(future);
}
2)为每个线程创建多个可调用的
for(int i=0; i< 100; i++){
Future<String>
浏览 3提问于2017-04-14得票数 2
回答已采纳
有Java代码，简化后的代码如下所示：
while(someCondition)
{
SomeType a = CalcResult(param1);
SomeType b = CalcResult(param2);
SomeType c = CalcResult(param3);
// Do something with a, b and c
}
CalcResult()是耗时的。应用程序在SMP系统上运行。有一种做法是尝试同时运行所有三种计算，每种计算都在自己的CPU上运行，而不是按顺序运行。总是这三个任务需要并行，而不是任意数量的任务(这就是算法)。每项
浏览 5提问于2015-02-20得票数 3
回答已采纳
我刚在找到了CompletionService。然而，这并没有真正展示出CompletionService相对于标准ExecutorService的优势。同样的代码也可以用这两种方法来编写。那么，什么时候CompletionService是有用的呢？
你能给出一个简短的代码样本，让它清晰明了吗？例如，此代码示例仅显示了不需要CompletionService的位置(=等同于ExecutorService)
ExecutorService taskExecutor = Executors.newCachedThreadPool();
// CompletionSer
浏览 17提问于2011-02-06得票数 84
回答已采纳
ExecutorService包含以下方法：
invokeAll(Collection<? extends Callable<T>> tasks)invokeAny(Collection<? extends Callable<T>> tasks)submit(Callable<T> task)
我对术语submit与invoke的用法感到困惑。这是否意味着invokeXyz()方法会通过底层线程池立即调用这些任务，而submit()则会对提交的任务进行某种调度。
回答说：“如果我们想等待所有已提交给ExecutorService的任务
浏览 4提问于2020-04-06得票数 0
2回答
一些简短的版本信息:SpringBoot2.1，带有Hibernate 5和Java 8。
我们尝试执行一个多线程处理步骤，在这个步骤中，我们使用spring服务来处理hibernate实体。基本上，它看起来像下面的片段。
ExecutorService executorService = Executors.newFixedThreadPool(4);
List<Callable<String>> executions = new ArrayList<>();
for (String partition : par
浏览 5提问于2020-02-19得票数 1
回答已采纳
我一直在成功地使用ExecutorService实现来管理线程池。
现在，我发现了一种情况，即使用数十个并发线程将大型数据对象插入数据仓库。数据可能来自不同的来源。当两个或多个线程从同一个源插入数据时，死锁会以一定的速度发生。这些死锁是很好理解的，只有通过才能避免，而不是同时拥有来自同一源的数据的两个线程()。
我读过关于ExecutorService接口内部的文章，发现抽象类AbstractExecutorService是一个很好的起点。我还设想，覆盖newTaskFor方法对目标来说就足够了。
对于如何用源的名称标记提交的线程，我有点不知所措，以后在newTaskFor中根据这个标签选择一
浏览 1提问于2021-09-22得票数 1
2回答
通过期货实现线程
、、
我想知道下面的实现是否正确
ExecutorService pool = Executors.newFixedThreadPool(MAX_NSH_THREADS);
Set<Future<Void>> futureRequest = new HashSet<Future<Void>>();
for (String host : SomeCollection)) {
Callable<Void> callable = new FileExtractor(j);
Future&l
浏览 0提问于2012-01-18得票数 2
回答已采纳
3回答
从javadoc到ThreadPoolExecutor
在方法执行(java.lang.Runnable)中提交新任务时.如果运行的线程多于corePoolSize，但少于maximumPoolSize线程，则只有当队列已满时，才会创建新线程。
在这种情况下，如何使ThreadPool启动新线程而不是提交任务队列？
示例：
我有带有corePoolSize=5和maxPoolSize=10的线程和无界队列。
假设corePoolSize线程现在很忙，并且到达了新任务池必须启动新线程并执行新任务。
假设maxPoolSize线程现在很忙，并且到达了新任务池必须将任务持久化到队列中，而第一
浏览 13提问于2012-09-26得票数 2
回答已采纳
我试图理解当Callable在不同的线程上运行时，它是如何能够返回值的。
我正在寻找Executors、AbstractExecutorService、ThreadPoolExecutor和FutureTask类，它们都可以在java.util.concurrent包中找到。
您可以通过调用执行器中的方法(例如newSingleThreadExecutor())来创建ExecutorService对象。然后，您可以使用ExecutorService.submit(Callable c)传递一个可调用的对象。
由于call()方法是由ExecutorService提供的线程运行的，那么返回的对象
浏览 1提问于2012-08-10得票数 6
回答已采纳
我有一个Worker类，它是implements Runnable的，并且有一个run()方法，它可以在发生冲突时引发异常，并提前返回。当发生这种情况时，需要将该线程放回队列中以便再次运行。
从的问题来看，我似乎需要用Callable重写。对吗？使用Runnable无法做到这一点
浏览 0提问于2012-12-11得票数 5
回答已采纳
ThreadPoolExecutor继承了submit(Callable<T> task)方法。
ThreadPoolExecutor的构造函数接受实例BlockingQueue<Runnable>。这个阻塞队列只能保存Runnable实例。
ThreadPoolExecutor构造函数的Javadoc表示：
用于在任务执行之前保存任务的队列。此队列将只包含execute方法提交的可运行任务。
所以，我的问题是:通过submit(Callable<T> task)提交的任务是如何排队的？
浏览 0提问于2015-02-22得票数 4
1回答
下面是一段简单的代码，它只尝试对字符串类型使用相同的executorService，这并不能解决my problem在一起处理多个字符串的问题，除非它们是同一类型的，否则线程必须等待前一个字符串被处理。
另外，请建议我是否可以使用阻塞队列来实现这一点，以及如何实现？
我可以想到的另一种方法，但无法实现--将所有选择了一种类型等待在队列中的线程放到队列中，这样就可以按顺序处理它们。同时，其他类型也会被其他线程捕获。
类型A <-线程1<-线程2<-线程3<-线程8
B型<-线程4<-线程5
C型<-线程9.诸若此类。
import java.ut
浏览 3提问于2016-06-02得票数 0
5回答
下面这段代码试图解决这个问题。
代码永远循环，并检查是否有任何挂起的请求需要处理。如果有，它会创建一个新线程来处理该请求，并将其提交给executor。一旦所有线程都完成了，它将休眠60秒，然后再次检查挂起的请求。
public static void main(String a[]){
//variables init code omitted
ExecutorService service = Executors.newFixedThreadPool(15);
ExecutorCompletionService<Long> comp = new Exec
浏览 4提问于2010-07-26得票数 35
回答已采纳
8回答
我正在使用ExecutorService线程池执行一个可调用的对象。我想给这个帖子起个名字。
更具体地说，在旧版本中，我这样做了-
Thread thread = new Thread(runnable Task);
thread.setName("My Thread Name");
我在log4j日志中使用了线程名，这对故障排除有很大帮助。现在，我正在将我的代码从Java1.4迁移到Java1.6。我已经写了这个(如下所示)--但是我不知道如何给这个帖子命名。
private final ExecutorService executorPool = Executors.new
浏览 1提问于2010-07-12得票数 37
回答已采纳
我有点困惑Future.get(超时)是如何工作的，因为根据定义，它会在指定的超时时间后通过一个异常来工作，但在我的测试用例中并没有发生这种情况。
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.u
浏览 0提问于2014-04-04得票数 3
回答已采纳
2回答
多线程读取大文件
、、、、
我正在实现一个应该接收大文本文件的类。我想把它分成块，每个块由一个不同的线程持有，该线程将计算这个块中每个字符的频率。我希望启动更多的线程可以获得更好的性能，但事实证明性能越来越差。下面是我的代码：
public class Main {
public static void main(String[] args)
throws IOException, InterruptedException, ExecutionException, ParseException
{
// save the current run's start t
浏览 10提问于2017-06-24得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
云直播
对象存储活动推荐
腾讯云开发者
