MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java 单线程池的任务执行顺序

2024-05-064.5k 阅读

Java 单线程池概述

在 Java 多线程编程领域，线程池是一种至关重要的工具，它可以有效地管理和复用线程资源，提高系统性能并降低资源开销。而单线程池作为线程池的一种特殊类型，它仅包含一个工作线程来执行任务队列中的任务。

单线程池在 java.util.concurrent.Executors 类中通过 Executors.newSingleThreadExecutor() 方法创建。这个方法返回一个 ExecutorService 对象，该对象管理着一个单线程的线程池。以下是创建单线程池的简单代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SingleThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        // 后续使用executorService提交任务
        executorService.shutdown();
    }
}

任务提交方式

在单线程池中，我们可以通过两种主要方式提交任务：execute 方法和 submit 方法。这两种方法在任务执行和返回结果处理上存在差异，也会间接影响任务的执行顺序。

execute 方法

execute 方法用于提交不需要返回值的任务。它接收一个 Runnable 接口的实现类作为参数。Runnable 接口只有一个 run 方法，当任务被执行时，run 方法中的代码会被执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecuteTaskExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            System.out.println("Task executed by execute method");
        });
        executorService.shutdown();
    }
}

在上述代码中，我们通过 execute 方法提交了一个 Runnable 任务。该任务会被放入单线程池的任务队列中，等待唯一的工作线程来执行。

submit 方法

submit 方法有三个重载版本，分别接收 Runnable 接口、Callable 接口的实现类作为参数，以及接收 Runnable 接口实现类和一个表示任务执行结果的泛型类型作为参数。

Callable 接口与 Runnable 接口类似，但 Callable 接口的 call 方法可以返回一个值并且可以抛出异常。submit 方法返回一个 Future 对象，通过这个对象我们可以获取任务的执行结果、检查任务是否完成以及取消任务等。

import java.util.concurrent.*;

public class SubmitTaskExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<String> future = executorService.submit(() -> {
            Thread.sleep(2000);
            return "Task executed by submit method";
        });
        try {
            System.out.println(future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
    }
}

在这段代码中，我们使用 submit 方法提交了一个 Callable 任务，并通过 Future.get() 方法获取任务的执行结果。这意味着主线程会阻塞，直到任务执行完成并返回结果。

任务执行顺序的本质

单线程池的任务执行顺序本质上依赖于任务提交的顺序以及任务队列的特性。当我们使用单线程池时，所有提交的任务都会被放入一个任务队列中，这个队列通常是一个无界的 LinkedBlockingQueue。

基于提交顺序的执行

由于任务是按照提交顺序依次进入任务队列的，而单线程池中的工作线程会从任务队列的头部依次取出任务并执行，所以在没有其他干扰因素的情况下，任务会按照提交的顺序依次执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TaskExecutionOrderBySubmission {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            System.out.println("Task 1 executed");
        });
        executorService.execute(() -> {
            System.out.println("Task 2 executed");
        });
        executorService.execute(() -> {
            System.out.println("Task 3 executed");
        });
        executorService.shutdown();
    }
}

在上述代码中，我们依次提交了三个任务，运行结果通常会按照 Task 1 executed、Task 2 executed、Task 3 executed 的顺序输出，这体现了任务基于提交顺序的执行。

任务队列的影响

单线程池默认使用的 LinkedBlockingQueue 是一个先进先出（FIFO）的队列。这意味着最早进入队列的任务会最早被取出执行。然而，如果我们自定义任务队列，改变其排队策略，任务的执行顺序可能会发生变化。

例如，我们可以使用 PriorityBlockingQueue 来创建一个具有优先级的任务队列。在这种情况下，任务的执行顺序将取决于任务的优先级。

import java.util.concurrent.*;

class PriorityTask implements Runnable, Comparable<PriorityTask> {
    private int priority;
    private String taskName;

    public PriorityTask(int priority, String taskName) {
        this.priority = priority;
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println(taskName + " executed");
    }

    @Override
    public int compareTo(PriorityTask other) {
        return Integer.compare(this.priority, other.priority);
    }
}

public class CustomQueueTaskExecution {
    public static void main(String[] args) {
        BlockingQueue<Runnable> taskQueue = new PriorityBlockingQueue<>();
        ExecutorService executorService = new ThreadPoolExecutor(
                1, 1, 0L, TimeUnit.MILLISECONDS, taskQueue);
        executorService.submit(new PriorityTask(3, "Task 3"));
        executorService.submit(new PriorityTask(1, "Task 1"));
        executorService.submit(new PriorityTask(2, "Task 2"));
        executorService.shutdown();
    }
}

在上述代码中，我们自定义了一个实现 Comparable 接口的 PriorityTask 类，并使用 PriorityBlockingQueue 作为任务队列。由于任务的优先级不同，任务的执行顺序将按照优先级从低到高进行，即 Task 1 executed、Task 2 executed、Task 3 executed。

异常处理对任务执行顺序的影响

在单线程池中执行任务时，异常处理也会对任务的执行顺序产生影响。当一个任务在执行过程中抛出未捕获的异常时，单线程池的默认行为是终止当前正在执行的任务，但不会影响后续任务的执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExceptionHandlingInThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            System.out.println("Task 1 started");
            throw new RuntimeException("Task 1 failed");
        });
        executorService.execute(() -> {
            System.out.println("Task 2 executed");
        });
        executorService.shutdown();
    }
}

在上述代码中，Task 1 在执行过程中抛出了一个 RuntimeException。尽管 Task 1 失败了，但 Task 2 仍然会被执行，输出结果为 Task 1 started 和 Task 2 executed。

然而，如果我们希望在任务抛出异常时能够采取更复杂的处理逻辑，比如记录异常信息、重新提交任务等，可以通过自定义 Thread.UncaughtExceptionHandler 来实现。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CustomExceptionHandling {
    public static void main(String[] args) {
        Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
            System.out.println("Thread " + t.getName() + " threw an exception: " + e.getMessage());
        });
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            System.out.println("Task 1 started");
            throw new RuntimeException("Task 1 failed");
        });
        executorService.execute(() -> {
            System.out.println("Task 2 executed");
        });
        executorService.shutdown();
    }
}

在这段代码中，我们通过 Thread.setDefaultUncaughtExceptionHandler 方法设置了一个全局的未捕获异常处理器。当任务抛出异常时，会执行我们自定义的异常处理逻辑，输出异常相关信息，同时 Task 2 仍然会正常执行。

线程池关闭对任务执行顺序的影响

在使用完单线程池后，我们需要关闭线程池以释放资源。线程池的关闭方式主要有两种：shutdown 和 shutdownNow，这两种方式对任务执行顺序有着不同的影响。

shutdown 方法

shutdown 方法会启动一个有序关闭过程，不再接受新任务，但会继续执行任务队列中已有的任务。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ShutdownThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println("Task 1 executed");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        executorService.execute(() -> {
            System.out.println("Task 2 executed");
        });
        executorService.shutdown();
        try {
            if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
                executorService.shutdownNow();
                if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
                    System.err.println("Pool did not terminate");
                }
            }
        } catch (InterruptedException ie) {
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

在上述代码中，我们调用 shutdown 方法后，线程池不再接受新任务，但会依次执行 Task 1 和 Task 2。awaitTermination 方法用于等待线程池中的所有任务执行完毕，超时时间设置为 5 秒。

shutdownNow 方法

shutdownNow 方法会尝试停止所有正在执行的任务，停止处理等待任务队列中的任务，并返回等待执行的任务列表。

import java.util.List;
import java.util.concurrent.*;

public class ShutdownNowThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
                System.out.println("Task 1 executed");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        executorService.execute(() -> {
            System.out.println("Task 2 executed");
        });
        List<Runnable> pendingTasks = executorService.shutdownNow();
        System.out.println("Pending tasks size: " + pendingTasks.size());
        try {
            if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
                System.err.println("Pool did not terminate");
            }
        } catch (InterruptedException ie) {
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

在这段代码中，调用 shutdownNow 方法后，正在执行的 Task 1 可能会被中断（取决于任务内部对中断的处理），Task 2 不会被执行，并且 shutdownNow 方法会返回包含 Task 2 的等待执行任务列表。

与其他线程池类型任务执行顺序的对比

与其他常见的线程池类型如固定大小线程池（Executors.newFixedThreadPool）和缓存线程池（Executors.newCachedThreadPool）相比，单线程池的任务执行顺序具有独特性。

固定大小线程池

固定大小线程池包含固定数量的工作线程。当任务提交时，任务会被放入任务队列中，若有空闲线程则立即执行任务，否则任务在队列中等待。与单线程池不同的是，固定大小线程池中的多个线程可以同时执行任务，因此任务的执行顺序可能并非严格按照提交顺序，而是取决于线程的调度和任务队列的特性。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.execute(() -> {
            System.out.println("Task 1 executed by fixed thread pool");
        });
        executorService.execute(() -> {
            System.out.println("Task 2 executed by fixed thread pool");
        });
        executorService.shutdown();
    }
}

在上述代码中，由于固定大小线程池有两个线程，Task 1 和 Task 2 可能会并行执行，其输出顺序可能是不确定的。

缓存线程池

缓存线程池会根据需要创建新线程，如果有空闲线程则复用空闲线程。它的任务队列是一个 SynchronousQueue，这意味着任务不会在队列中等待，而是直接交给线程执行。如果没有空闲线程，则会创建新线程。因此，缓存线程池中的任务执行顺序也不一定按照提交顺序，并且线程的创建和销毁相对频繁。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> {
            System.out.println("Task 1 executed by cached thread pool");
        });
        executorService.execute(() -> {
            System.out.println("Task 2 executed by cached thread pool");
        });
        executorService.shutdown();
    }
}

在这段代码中，Task 1 和 Task 2 的执行顺序可能会因为线程的动态创建和调度而不同，其执行顺序具有不确定性。

通过对比可以看出，单线程池由于只有一个工作线程，任务执行顺序相对更易于预测和控制，在一些对任务执行顺序敏感的场景中具有独特的优势。

单线程池任务执行顺序的应用场景

单线程池任务执行顺序的特性使其适用于多种应用场景。

顺序性要求严格的任务处理

在某些业务场景中，任务的执行顺序至关重要，例如数据库事务处理中的一系列操作，必须按照特定顺序依次执行以确保数据的一致性。单线程池可以保证任务按照提交顺序依次执行，避免了多线程并发执行可能导致的顺序混乱问题。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class DatabaseTransactionExample {
    private static final String URL = "jdbc:mysql://localhost:3306/test";
    private static final String USER = "root";
    private static final String PASSWORD = "password";

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD)) {
                connection.setAutoCommit(false);
                PreparedStatement statement1 = connection.prepareStatement("INSERT INTO users (name) VALUES ('Alice')");
                statement1.executeUpdate();
                PreparedStatement statement2 = connection.prepareStatement("UPDATE users SET age = 25 WHERE name = 'Alice'");
                statement2.executeUpdate();
                connection.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdown();
    }
}

在上述代码中，数据库插入和更新操作必须按顺序执行，单线程池可以确保这一点，避免并发执行导致的数据不一致。

资源敏感的场景

在一些资源受限的环境中，如移动设备或嵌入式系统，过多的线程可能会导致资源耗尽。单线程池只使用一个线程，资源开销小，同时又能通过任务队列有序处理多个任务。例如，在一个需要定期读取传感器数据并进行处理的嵌入式系统中，使用单线程池可以避免多线程带来的资源竞争和复杂性。

class SensorDataProcessor implements Runnable {
    @Override
    public void run() {
        // 模拟传感器数据读取和处理
        System.out.println("Processing sensor data");
    }
}

public class ResourceSensitiveScenario {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            executorService.execute(new SensorDataProcessor());
        }
        executorService.shutdown();
    }
}

在上述代码中，通过单线程池按顺序处理传感器数据任务，有效控制了资源使用。

日志记录和文件写入

在日志记录或文件写入操作中，通常希望按照事件发生的顺序进行记录或写入，以保证日志的准确性和文件内容的一致性。单线程池可以确保这些任务按照提交顺序依次执行，避免多线程并发写入可能导致的日志混乱或文件损坏。

import java.io.FileWriter;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class LoggingAndFileWritingExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            try (FileWriter fileWriter = new FileWriter("log.txt", true)) {
                fileWriter.write("Log entry 1\n");
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        executorService.execute(() -> {
            try (FileWriter fileWriter = new FileWriter("log.txt", true)) {
                fileWriter.write("Log entry 2\n");
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        executorService.shutdown();
    }
}

在上述代码中，通过单线程池依次向 log.txt 文件写入日志条目，保证了日志记录的顺序性。

综上所述，理解 Java 单线程池的任务执行顺序，对于在各种场景中合理使用单线程池、优化系统性能以及确保任务执行的正确性和顺序性具有重要意义。通过掌握任务提交方式、异常处理、线程池关闭等方面对任务执行顺序的影响，开发者能够更好地利用单线程池这一强大工具，构建出高效、稳定且符合业务需求的多线程应用程序。同时，与其他线程池类型的对比以及对应用场景的分析，也为开发者在不同场景下选择合适的线程池提供了参考依据。在实际开发中，应根据具体的业务需求和系统环境，灵活运用单线程池的特性，充分发挥其优势，避免潜在的问题，从而实现更优质的软件系统开发。