java使用ExecutorService和CompletionService在主线程中开启多线程运行,采用阻塞方式先获取到最先结束的线程结果

最新推荐文章于 2022-08-09 11:00:08 发布

好大的月亮

最新推荐文章于 2022-08-09 11:00:08 发布

阅读量1k

点赞数 1

分类专栏： JAVA 多线程

本文链接：https://blog.csdn.net/weixin_43944305/article/details/108711487

版权

JAVA 同时被 2 个专栏收录

230 篇文章 7 订阅

订阅专栏

多线程

4 篇文章 0 订阅

订阅专栏

ExecutorService的创建

newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

ExecutorService有如下几个执行方法：

execute(Runnable)
submit(Runnable)
submit(Callable)
invokeAny(…)
invokeAll(…)

execute(Runnable)

ExecutorService executorService = Executors.newSingleThreadExecutor();

executorService.execute(new Runnable() {
public void run() {
    System.out.println("Asynchronous task");
}
});

executorService.shutdown();

submit(Runnable)

submit(Runnable)和execute(Runnable)区别是前者可以返回一个Future对象，通过返回的Future对象，我们可以检查提交的任务是否执行完毕

Future future = executorService.submit(new Runnable() {
public void run() {
    System.out.println("Asynchronous task");
}
});

future.get();  //returns null if the task has finished correctly.

submit(Callable)

submit(Callable)和submit(Runnable)类似，也会返回一个Future对象，但是除此之外，submit(Callable)接收的是一个Callable的实现，Callable接口中的call()方法有一个返回值，可以返回任务的执行结果，而Runnable接口中的run()方法是void的，没有返回值。

Future future = executorService.submit(new Callable(){
public Object call() throws Exception {
    System.out.println("Asynchronous Callable");
    return "Callable Result";
}
});

System.out.println("future.get() = " + future.get());

如果任务执行完成，future.get()方法会返回Callable任务的执行结果。注意，future.get()方法会产生阻塞。

invokeAny(…)

invokeAny(…)方法接收的是一个Callable的集合，执行这个方法不会返回Future，但是会返回所有Callable任务中其中一个任务的执行结果。这个方法也无法保证返回的是哪个任务的执行结果，反正是其中的某一个.

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";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
    return "Task 2";
}
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
    return "Task 3";
}
});

String result = executorService.invokeAny(callables);
System.out.println("result = " + result);
executorService.shutdown();

invokeAll(…)

invokeAll(…)与 invokeAny(…)类似也是接收一个Callable集合，但是前者执行之后会返回一个Future的List，其中对应着每个Callable任务执行后的Future对象。

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";
}
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
    return "Task 2";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
    return "Task 3";
}
});

List<Future<String>> futures = executorService.invokeAll(callables);

for(Future<String> future : futures){
System.out.println("future.get = " + future.get());
}

executorService.shutdown();

下面是一个`demo`,实际上可以自己写一个类实现`callable`接口,做相关的业务逻辑

//相关的引用包
import java.util.concurrent.CompletionService
import java.util.concurrent.ExecutorCompletionService
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.Future


public static void main(String[] args) throws InterruptedException, ExecutionException {
 
    Random random = new Random();
    //这里指定线程数好点,不然使用 newCachedThreadPool 会动态增长线程数
    ExecutorService pool = Executors.newFixedThreadPool(3);
 
    CompletionService<String> service = new ExecutorCompletionService<String>(pool);
 
    for(int i = 0; i<4; i++) {
 		//这里submit的时候线程已经在运行了,这儿也可以自己写一个类实现Callable接口然后new这个类就行,因为这了添加的就是一个Callable类型的类
        service.submit(() -> {
            Thread.sleep(random.nextInt(1000));
            System.out.println(Thread.currentThread().getName()+"|完成任务");
            return "data"+random.nextInt(10);
        });
    }
 
    for(int j = 0; j < 4; j++) {
        Future<String> take = service.take(); //这里如果没有完成的任务就阻塞当前线程,直到第一个任务完成
        String result = take.get(); // 这一行在这里不会阻塞，因为放入队列中的都是已经完成的任务,不过这里要注意,要是实现业务的类有问题,这里可能get的时候会抛NullPoint
        System.out.println("获取到结果："+result);
    }   
}

CompletionService里的结果集，就是take出来的结果，不是像栈那样先进先出原则，这里是先完成先出

future.isDone()	//判断当前线程是否完成
future.isCancelled()	//判断当前线程是否被取消

直接一次性运行一个任务集合

import java.time.LocalDateTime
import java.util.concurrent.Callable
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

ExecutorService executorService = Executors.newFixedThreadPool(10)
List<Callable> despatches = new ArrayList<>()

despatches.add(new Callable() {
    @Override
    Object call() throws Exception {
        TimeUnit.MILLISECONDS.sleep(300)
        println("success")
        return "Task's execution";
    }
})
despatches.add(new Callable() {
    @Override
    Object call() throws Exception {
        TimeUnit.MILLISECONDS.sleep(300)
        println("success")
        return "Task's execution";
    }
})
despatches.add(new Callable() {
    @Override
    Object call() throws Exception {
        TimeUnit.MILLISECONDS.sleep(300)
        println("success")
        return "Task's execution";
    }
})
despatches.add(new Callable() {
    @Override
    Object call() throws Exception {
        TimeUnit.MILLISECONDS.sleep(300)
        println("success")
        return "Task's execution";
    }
})
//因为上面实现Callable中call()方法返回的Object所以这里也要用Future<Object>
List<Future<Object>> results = executorService.invokeAll(despatches)
results.each {
	//获取返回结果,超时(这里我设置的时间是100秒)就会抛出TimeoutException异常
    try {
        println(it.get(100,TimeUnit.SECONDS))
    } catch (TimeoutException e) {
        e.printStackTrace()
    }
}
//如果接下来不需要使用线程池了就关闭它
executorService.shutdown();
try {
    if (!executorService.awaitTermination(800, TimeUnit.MILLISECONDS)) {
        executorService.shutdownNow();
    }
} catch (InterruptedException e) {
    executorService.shutdownNow();
}

在这里插入图片描述

此处参考了大佬的文章https://blog.csdn.net/u011734144/article/details/52351841

科学的关闭一个ExecutorService

在通常情况下，当没有待处理的任务(task)时，ExecutorService将不会自动销毁。它会一直保持存活并且等待执行新任务。

在某些情况下，这或许很有用;例如，有一个应用需要处理一些不规则的任务或大量在编译时不可知的任务。在另一方面，即使一个app在执行到最后，它也不会被停止，因为一个处于等待中的ExecutorService 将导致JVM保持运行。

为了正确地关闭一个ExecutorService，我们有两个API可供使用： shutdown()以及shutdownNow()。

shutdown()方法不会导致ExecutorService立即销毁。它将让ExecutorService停止接收新任务，并且在所有运行中的线程完成他们当前工作之后，关闭ExecutorService。
而shutdownNow()方法会试图立即销毁ExecutorService,但是它并不保证在同一时刻下所有运行中的线程都能被终止。该方法会返回一个任务集合，这些任务都是等待被ExecutorService处理的。具体怎么处理这些任务则取决于开发者。

List notExecutedTasks = executorService.shutDownNow();

关闭ExecutorService的最好方式(同时也是Oracle所推荐的)是上面俩种方法与awaitTermination()的组合使用。使用这种方法，ExecutorService将会先停止接收新任务，然后等待一段时间好让所有任务都被完成。如果时间过期了，执行将被理解终止.

executorService.shutdown();
try {
    if (!executorService.awaitTermination(800, TimeUnit.MILLISECONDS)) {
        executorService.shutdownNow();
    }
} catch (InterruptedException e) {
    executorService.shutdownNow();
}

好大的月亮

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java使用ExecutorService和CompletionService在主线程中开启多线程运行,采用阻塞方式先获取到最先结束的线程结果

下面是一个demo,实际上可以自己写一个类实现callable接口,做相关的业务逻辑//相关的引用包import java.util.concurrent.CompletionServiceimport java.util.concurrent.ExecutorCompletionServiceimport java.util.concurrent.ExecutorServiceimport java.util.concurrent.Executorsimport java.util.concu
复制链接

扫一扫