Java 在没有特定顺序的情况下，如何管理多个可调用线程结果？_Java_Multithreading_Performance_Threadpool_Callable

Java 在没有特定顺序的情况下，如何管理多个可调用线程结果？

java multithreading performance

Java 在没有特定顺序的情况下，如何管理多个可调用线程结果？,java,multithreading,performance,threadpool,callable,Java,Multithreading,Performance,Threadpool,Callable,基本上是这样的： ExecutorService service = Executors.newFixedThreadPool(2); Future<Boolean> futureFoo = service.submit(myFooTask); Future<Boolean> futureBar = service.submit(myBarTask); int resultFoo; boolean resultBar; resultFoo = futureFoo.ge

基本上是这样的：

ExecutorService service = Executors.newFixedThreadPool(2);

Future<Boolean> futureFoo = service.submit(myFooTask);
Future<Boolean> futureBar = service.submit(myBarTask);

int resultFoo;
boolean resultBar;
resultFoo = futureFoo.get();
resultBar = futureBar.get();

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class CompletionServiceExample {


    private static Logger LOGGER = Logger.getLogger("CompletionServiceExample");

    public static void main(String[] args) throws InterruptedException {

        CompletionServiceExample completionServiceExample = new CompletionServiceExample();
        completionServiceExample.doTheWork();
    }

    private void doTheWork() throws InterruptedException {

        final ExecutorService executorService = Executors.newFixedThreadPool(2);
        final CompletionService<Base> completionService = new ExecutorCompletionService<>(executorService);


        completionService.submit(new FooBase());
        completionService.submit(new BarBase());

        int total_tasks = 2;

        for (int i = 0; i < total_tasks; ++i) {

            try {
                final Future<Base> value = completionService.take();
                Base base = value.get();
                if (base instanceof FooBase) {
                    int myInteger = ((FooBase) base).getValue();
                    System.out.println("received value: " + myInteger);
                }
                if (base instanceof BarBase) {
                    boolean myBoolean = ((BarBase) base).isValue();
                    System.out.println("received value: " + myBoolean);
                }

            } catch (ExecutionException e) {
                LOGGER.log(Level.WARNING, "Error while processing task. ", e);
            } catch (InterruptedException e) {
                LOGGER.log(Level.WARNING, "interrupted while waiting for result", e);
            }
        }


        executorService.shutdown();
        executorService.awaitTermination(5, TimeUnit.SECONDS);

    }
}

class Base {
}

class FooBase extends Base implements Callable<Base> {

    private int value;

    @Override
    public Base call() throws Exception {
        Thread.sleep(5000);
        value = 10;
        return this;
    }

    public int getValue() {
        return value;
    }
}

class BarBase extends Base implements Callable<Base> {

    private boolean value;

    @Override
    public Base call() throws Exception {
        Thread.sleep(1000);
        value = false;
        return this;
    }

    public boolean isValue() {
        return value;
    }
}

ExecutorService=Executors.newFixedThreadPool（2）；
Future futureFoo=服务.提交（myFooTask）；
Future futureBar=service.submit（myBarTask）；
int-resultFoo；
布尔结果条；
resultFoo=futureFoo.get（）；
resultBar=futureBar.get（）；

我想做一个活动来独立管理我得到的第一个结果，而不必等待

futureFoo

首先完成

您可以使用CompletionService。可调用项的结果被放入队列中，您可以在任务完成后立即获取任务的结果在这种情况下，如果Bar提前完成，则无需等待Foo的结果例如：

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class CompletionServiceExample {


    private static Logger LOGGER = Logger.getLogger("CompletionServiceExample");

    public static void main(String[] args) throws InterruptedException {

        CompletionServiceExample completionServiceExample = new CompletionServiceExample();
        completionServiceExample.doTheWork();
    }

    private void doTheWork() throws InterruptedException {

        final ExecutorService executorService = Executors.newFixedThreadPool(2);
        final CompletionService<Boolean> completionService = new ExecutorCompletionService<>(executorService);


        completionService.submit(new Foo());
        completionService.submit(new Bar());

        int total_tasks = 2;

        for(int i = 0; i < total_tasks; ++i) {

            try {
                final Future<Boolean> value = completionService.take();
                System.out.println("received value: " + value.get());
            } catch (ExecutionException e) {
                LOGGER.log(Level.WARNING, "Error while processing task. ", e);
            } catch (InterruptedException e) {
                LOGGER.log(Level.WARNING, "interrupted while waiting for result", e);
            }
        }


        executorService.shutdown();
        executorService.awaitTermination(5, TimeUnit.SECONDS);

    }
}

class Foo implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {
        Thread.sleep(5000);
        return true;
    }
}

class Bar implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {
        Thread.sleep(1000);
        return false;
    }
}

import java.util.concurrent.Callable；
导入java.util.concurrent.CompletionService；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.ExecutionCompletionService；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.Future；
导入java.util.concurrent.TimeUnit；
导入java.util.logging.Level；
导入java.util.logging.Logger；
公共类CompletionServiceExample{
私有静态记录器Logger=Logger.getLogger（“CompletionServiceExample”）；
公共静态void main（字符串[]args）引发InterruptedException{
CompletionServiceExample CompletionServiceExample=新的CompletionServiceExample（）；
completionServiceExample.doTheWork（）；
}
private void doTheWork（）引发InterruptedException{
final ExecutorService ExecutorService=Executors.newFixedThreadPool（2）；
final CompletionService CompletionService=新的ExecutionCompletionService（executorService）；
completionService.submit（新的Foo（））；
completionService.submit（新条（））；
int-total_任务=2；
对于（int i=0；i

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class CompletionServiceExample {


    private static Logger LOGGER = Logger.getLogger("CompletionServiceExample");

    public static void main(String[] args) throws InterruptedException {

        CompletionServiceExample completionServiceExample = new CompletionServiceExample();
        completionServiceExample.doTheWork();
    }

    private void doTheWork() throws InterruptedException {

        final ExecutorService executorService = Executors.newFixedThreadPool(2);
        final CompletionService<Boolean> completionService = new ExecutorCompletionService<>(executorService);


        completionService.submit(new Foo());
        completionService.submit(new Bar());

        int total_tasks = 2;

        for(int i = 0; i < total_tasks; ++i) {

            try {
                final Future<Boolean> value = completionService.take();
                System.out.println("received value: " + value.get());
            } catch (ExecutionException e) {
                LOGGER.log(Level.WARNING, "Error while processing task. ", e);
            } catch (InterruptedException e) {
                LOGGER.log(Level.WARNING, "interrupted while waiting for result", e);
            }
        }


        executorService.shutdown();
        executorService.awaitTermination(5, TimeUnit.SECONDS);

    }
}

class Foo implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {
        Thread.sleep(5000);
        return true;
    }
}

class Bar implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {
        Thread.sleep(1000);
        return false;
    }
}

import java.util.concurrent.Callable；
导入java.util.concurrent.CompletionService；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.ExecutionCompletionService；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.Future；
导入java.util.concurrent.TimeUnit；
导入java.util.logging.Level；
导入java.util.logging.Logger；
公共类CompletionServiceExample{
私有静态记录器Logger=Logger.getLogger（“CompletionServiceExample”）；
公共静态void main（字符串[]args）引发InterruptedException{
CompletionServiceExample CompletionServiceExample=新的CompletionServiceExample（）；
completionServiceExample.doTheWork（）；
}
private void doTheWork（）引发InterruptedException{
final ExecutorService ExecutorService=Executors.newFixedThreadPool（2）；
final CompletionService CompletionService=新的ExecutionCompletionService（executorService）；
completionService.submit（新的Foo（））；
completionService.submit（新条（））；
int-total_任务=2；
对于（int i=0；i

如果要返回不同的类型，可以使用基类并进行向下转换。例如：

ExecutorService service = Executors.newFixedThreadPool(2);

Future<Boolean> futureFoo = service.submit(myFooTask);
Future<Boolean> futureBar = service.submit(myBarTask);

int resultFoo;
boolean resultBar;
resultFoo = futureFoo.get();
resultBar = futureBar.get();

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class CompletionServiceExample {


    private static Logger LOGGER = Logger.getLogger("CompletionServiceExample");

    public static void main(String[] args) throws InterruptedException {

        CompletionServiceExample completionServiceExample = new CompletionServiceExample();
        completionServiceExample.doTheWork();
    }

    private void doTheWork() throws InterruptedException {

        final ExecutorService executorService = Executors.newFixedThreadPool(2);
        final CompletionService<Base> completionService = new ExecutorCompletionService<>(executorService);


        completionService.submit(new FooBase());
        completionService.submit(new BarBase());

        int total_tasks = 2;

        for (int i = 0; i < total_tasks; ++i) {

            try {
                final Future<Base> value = completionService.take();
                Base base = value.get();
                if (base instanceof FooBase) {
                    int myInteger = ((FooBase) base).getValue();
                    System.out.println("received value: " + myInteger);
                }
                if (base instanceof BarBase) {
                    boolean myBoolean = ((BarBase) base).isValue();
                    System.out.println("received value: " + myBoolean);
                }

            } catch (ExecutionException e) {
                LOGGER.log(Level.WARNING, "Error while processing task. ", e);
            } catch (InterruptedException e) {
                LOGGER.log(Level.WARNING, "interrupted while waiting for result", e);
            }
        }


        executorService.shutdown();
        executorService.awaitTermination(5, TimeUnit.SECONDS);

    }
}

class Base {
}

class FooBase extends Base implements Callable<Base> {

    private int value;

    @Override
    public Base call() throws Exception {
        Thread.sleep(5000);
        value = 10;
        return this;
    }

    public int getValue() {
        return value;
    }
}

class BarBase extends Base implements Callable<Base> {

    private boolean value;

    @Override
    public Base call() throws Exception {
        Thread.sleep(1000);
        value = false;
        return this;
    }

    public boolean isValue() {
        return value;
    }
}

import java.util.concurrent.Callable；
导入java.util.concurrent.CompletionService；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.ExecutionCompletionService；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.Future；
导入java.util.concurrent.TimeUnit；
导入java.util.logging.Level；
导入java.util.logging.Logger；
公共类CompletionServiceExample{
私有静态记录器Logger=Logger.getLogger（“CompletionServiceExample”）；
公共静态void main（字符串[]args）引发InterruptedException{
CompletionServiceExample CompletionServiceExample=新的CompletionServiceExample（）；
completionServiceExample.doTheWork（）；
}
private void doTheWork（）引发InterruptedException{
最后交货