Java 遗嘱执行人服务的使用

executor服务中的线程是否并行运行，并且在向其提交任务时不进行时间分割？如果它们不并行运行，那么executor服务有什么用？

一个

executor服务

只是对执行异步操作的抽象。它负责管理传入任务，并将它们分布到可用线程上

---

至于线程本身，这取决于环境。E机器、操作系统和jvm。如果你有一个单核处理器，或者操作系统不支持它，你就不能并行处理。然而，在现代机器上，你肯定会在某种程度上体验到并行执行。请记住，即使手动创建线程，也不能保证操作系统会并行执行它们。

执行器服务只是对执行异步操作的抽象。它负责管理传入任务，并将它们分布到可用线程上

---

至于线程本身，这取决于环境。E机器、操作系统和jvm。如果你有一个单核处理器，或者操作系统不支持它，你就不能并行处理。然而，在现代机器上，你肯定会在某种程度上体验到并行执行。请记住，即使手动创建线程，也不能保证操作系统会并行执行这些线程。

Executor service是一个复杂的线程池，允许在后台执行多个独立的任务

---

如果它们是并行处理的，则取决于计算机中有多少可用的cpu单元，而这些cpu的确切使用是程序员无法控制的。

Executor service是一个复杂的线程池，允许在后台执行多个独立的任务

如果它们是并行处理的，则取决于计算机中有多少可用的cpu单元，而这些cpu的确切使用是程序员无法控制的。

来自Java文档：

一种执行器，提供管理终止的方法，以及可以生成未来跟踪一个或多个异步任务进度的方法

通常，所有提交给

ExecutorService

的调用都将始终与主线程并行运行。对于

ExecutorService

中提交的任务，它们可以是并行的，具体取决于指定在服务中运行的线程数量

如果您使用的执行器服务只有一个

线程

，那么无论您提交多少任务，在任何给定时间该执行器服务上都只运行一个

如果您的executor服务使用5个

线程

，则最多有5个提交的任务将彼此并行运行

下面是一个示例代码：

public class ExecutorServiceTest {
public static ExecutorService service = Executors.newFixedThreadPool(5);
public static void main(String[] args) throws Exception {
    System.out.println("Submitting!");

    service.submit(new PrintCallable("Callable 1"));
    service.submit(new PrintCallable("Callable 2"));
    service.submit(new PrintCallable("Callable 3"));
    service.submit(new PrintCallable("Callable 4"));
    service.submit(new PrintCallable("Callable 5"));

    service.shutdown();
    service.awaitTermination(10, TimeUnit.SECONDS);

    System.out.println("Done!");
}

private static class PrintCallable implements Callable<Void> {

    private final String toPrint;

    private PrintCallable(String toPrint) {
        this.toPrint = toPrint;
    }

    @Override
    public Void call() throws Exception {
        for(int i=0; i<5; i++) {
            Thread.sleep(100);
            System.out.println(toPrint);
        }
        return null;
    }

}

公共类执行器服务测试{
public static ExecutorService service=Executors.newFixedThreadPool（5）；
公共静态void main（字符串[]args）引发异常{
System.out.println（“提交！”）；
提交（新的可打印调用（“可调用1”）；
提交（新的可打印调用（“可调用2”）；
提交（新打印的可调用（“可调用3”）；
提交（新打印的可调用（“可调用4”）；
提交（新打印的可调用（“可调用5”）；
service.shutdown（）；
服务。等待终止（10，时间单位。秒）；
System.out.println（“完成！”）；
}
私有静态类PrintCallable实现了可调用{
私有最终字符串toPrint；
私有可打印调用（字符串toPrint）{
this.toPrint=toPrint；
}
@凌驾
public Void call（）引发异常{
对于Java文档中的（int i=0；i）

一种执行器，提供管理终止的方法，以及可以生成未来跟踪一个或多个异步任务进度的方法

通常，提交给
执行器服务的所有可调用项将始终与主线程并行运行。至于
执行器服务中提交的任务，它们可以并行运行，具体取决于指定在服务中运行的线程数

如果您使用的执行器服务只有一个
线程
，那么无论您提交多少任务，在任何给定时间该执行器服务上都只运行一个

如果您的executor服务使用5个
线程
，则最多有5个提交的任务将彼此并行运行

下面是一个示例代码：

public class ExecutorServiceTest {
public static ExecutorService service = Executors.newFixedThreadPool(5);
public static void main(String[] args) throws Exception {
    System.out.println("Submitting!");

    service.submit(new PrintCallable("Callable 1"));
    service.submit(new PrintCallable("Callable 2"));
    service.submit(new PrintCallable("Callable 3"));
    service.submit(new PrintCallable("Callable 4"));
    service.submit(new PrintCallable("Callable 5"));

    service.shutdown();
    service.awaitTermination(10, TimeUnit.SECONDS);

    System.out.println("Done!");
}

private static class PrintCallable implements Callable<Void> {

    private final String toPrint;

    private PrintCallable(String toPrint) {
        this.toPrint = toPrint;
    }

    @Override
    public Void call() throws Exception {
        for(int i=0; i<5; i++) {
            Thread.sleep(100);
            System.out.println(toPrint);
        }
        return null;
    }

}

公共类执行器服务测试{
public static ExecutorService service=Executors.newFixedThreadPool（5）；
公共静态void main（字符串[]args）引发异常{
System.out.println（“提交！”）；
提交（新的可打印调用（“可调用1”）；
提交（新的可打印调用（“可调用2”）；
提交（新打印的可调用（“可调用3”）；
提交（新打印的可调用（“可调用4”）；
提交（新打印的可调用（“可调用5”）；
service.shutdown（）；
服务。等待终止（10，时间单位。秒）；
System.out.println（“完成！”）；
}
私有静态类PrintCallable实现了可调用{
私有最终字符串toPrint；
私有可打印调用（字符串toPrint）{
this.toPrint=toPrint；
}
@凌驾
public Void call（）引发异常{
对于（inti=0；iIn-general，Java中的所有线程都可以进行时间切片。当任何线程被阻塞（比如IO）时，可以替换另一个线程来代替它。具有4个内核的CPU可以运行4个进程，但可能有100个线程“运行”同时由于被IO或时间切片交换。注意：
ExecutorService
是一个接口，而不是一个实现。如果你只知道某个东西是ExecutorService，那么你就不知道它使用了多少线程（如果有的话），或者它们是如何调度的。在最常见的实现中，howev