博主打算从0-1讲解下java进阶篇教学，今天教学第五篇：Java多线程编程。
在Java编程中，使用多线程可以提高程序的并发性能，但是直接创建和管理线程可能会导致资源浪费和性能下降。Java提供了线程池来管理线程的生命周期和执行任务，有效地提高了并发效率。本文将详细介绍如何使用Java线程池以及如何自定义线程池。
一、线程简介
Java通过java.util.concurrent包提供了Executor框架来管理线程池。以下是使用线程池的步骤：
- 创建线程池：可以通过Executors工厂类来创建不同类型的线程池。常用的线程池类型包括FixedThreadPool、CachedThreadPool、ScheduledThreadPool、SingleThreadPool等。
- 提交任务：使用线程池的execute()或submit()方法提交任务给线程池执行。
- 关闭线程池：在不需要线程池时，需要及时关闭以释放资源。可以调用线程池的shutdown()或shutdownNow()方法来关闭线程池。
二、FixedThreadPool
FixedThreadPool是一个固定大小的线程池，它会创建指定数量的线程并保持这些线程的数量不变，即使线程处于空闲状态也不会销毁。
优点：
- 线程数量固定，不会随着任务数量的增加而增加，避免了线程数量过多导致的资源消耗问题。
- 可以控制线程的最大并发数，保证系统资源不被过度占用。
缺点：
- 固定大小的线程池可能会导致任务排队等待执行，如果任务数量过多，可能会导致性能下降。
- 线程池大小不可动态调整，如果在某些情况下需要更多的线程来处理任务，就无法满足需求。
案例：
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class FixedThreadPoolExample { public static void main(String[] args) { // 创建固定大小的线程池，包含5个线程 ExecutorService executor = Executors.newFixedThreadPool(5); // 提交任务给线程池执行 for (int i = 0; i < 10; i++) { executor.execute(new Task(i)); } // 关闭线程池 executor.shutdown(); } static class Task implements Runnable { private int taskId; public Task(int taskId) { this.taskId = taskId; } @Override public void run() { System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName()); } } }
三、CachedThreadPool
CachedThreadPool是一个可缓存的线程池，它会根据需要创建新线程，并在旧线程可用时重用它们。如果线程在60秒内没有被使用，则会被终止并移除。
优点：
- 线程池的大小可以根据需要自动调整，无需手动设置线程数量，节省了资源并提高了性能。
- 可以灵活处理大量的短期任务，避免了长时间等待空闲线程的情况。
缺点：
- 可缓存的线程池会创建大量的线程，如果任务数量过多，可能会导致系统资源耗尽。
- 对于长时间执行的任务，线程池可能会频繁地创建和销毁线程，增加了系统开销。
案例：
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CachedThreadPoolExample { public static void main(String[] args) { // 创建可缓存的线程池 ExecutorService executor = Executors.newCachedThreadPool(); // 提交任务给线程池执行 for (int i = 0; i < 10; i++) { executor.execute(new Task(i)); } // 关闭线程池 executor.shutdown(); } static class Task implements Runnable { private int taskId; public Task(int taskId) { this.taskId = taskId; } @Override public void run() { System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName()); } } }
四、ScheduledThreadPool
ScheduledThreadPool是一个定时任务线程池，它可以在指定时间或者周期性地执行任务。
优点：
- 可以定时执行任务或周期性执行任务，非常适合需要按照一定频率执行任务的场景。
- 线程池的大小可以根据任务数量自动调整，灵活性较高。
缺点：
- 定时任务可能会受到系统时间变更的影响，导致任务执行时间不准确。
- 如果任务执行时间过长，可能会影响后续任务的执行。
案例：
import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class ScheduledThreadPoolExample { public static void main(String[] args) { // 创建定时任务线程池，包含3个线程 ScheduledExecutorService executor = Executors.newScheduledThreadPool(3); // 延迟1秒后执行任务，并每隔3秒执行一次 executor.scheduleAtFixedRate(new Task(), 1, 3, TimeUnit.SECONDS); } static class Task implements Runnable { @Override public void run() { System.out.println("Task is running on thread " + Thread.currentThread().getName()); } } }
五、SingleThreadPool
SingleThreadPool是一个单线程的线程池，它只会创建一个工作线程来执行任务，保证所有任务按照指定顺序执行。
优点：
- 只有一个工作线程，保证任务按照指定顺序依次执行，避免了多线程情况下的竞争问题。
- 线程池的大小固定，不存在线程数量动态调整的问题。
缺点：
- 只有一个线程，无法并行处理多个任务，可能会导致任务执行时间过长。
- 如果任务出现阻塞或异常，可能会影响后续任务的执行。
案例：
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class SingleThreadPoolExample { public static void main(String[] args) { // 创建单线程的线程池 ExecutorService executor = Executors.newSingleThreadExecutor(); // 提交任务给线程池执行 for (int i = 0; i < 10; i++) { executor.execute(new Task(i)); } // 关闭线程池 executor.shutdown(); } static class Task implements Runnable { private int taskId; public Task(int taskId) { this.taskId = taskId; } @Override public void run() { System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName()); } } }
六、自定义线程池
除了使用Executors提供的线程池之外，我们还可以自定义线程池来满足特定的需求。在自定义线程池时，通常需要考虑以下七个参数：
- corePoolSize：核心线程数，即线程池中保持活动状态的最小线程数。
- maximumPoolSize：最大线程数，即线程池中允许的最大线程数。
- keepAliveTime：线程空闲时间，即当线程池中的线程数量超过corePoolSize时，多余的空闲线程等待新任务的最长时间。
- unit：keepAliveTime的时间单位。
- workQueue：工作队列，用于保存等待执行的任务。
- threadFactory：线程工厂，用于创建新线程。
- handler：拒绝策略，用于处理当工作队列已满并且无法继续接受新任务时的情况。
关于拒绝策略：
- AbortPolicy（默认策略）：
- 在工作队列已满的情况下，直接抛出RejectedExecutionException异常，阻止任务的执行。这是默认的拒绝策略，意味着线程池无法接受新的任务时，会抛出异常来通知调用者。
- CallerRunsPolicy：
- 当工作队列已满时，新提交的任务会由提交任务的线程来执行，即调用者所在的线程直接执行该任务。这样做可以减少任务的提交速度，以便控制任务的执行速度。
- DiscardPolicy：
- 当工作队列已满时，会丢弃新提交的任务，而不做任何处理。这意味着新提交的任务将被静默地忽略，不会得到执行，也不会抛出异常。
- DiscardOldestPolicy：
- 当工作队列已满时，会丢弃队列中最早提交的任务，然后尝试将新提交的任务添加到工作队列中。这样做可以确保工作队列中始终保留着最新的任务，但可能会丢失一些已提交的任务。
下面是一个自定义线程池的示例代码：
import java.util.concurrent.*; public class CustomThreadPoolExample { public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor( 2, // corePoolSize 5, // maximumPoolSize 10, // keepAliveTime TimeUnit.SECONDS, // unit new ArrayBlockingQueue<>(10), // workQueue Executors.defaultThreadFactory(), // threadFactory new ThreadPoolExecutor.AbortPolicy() // handler ); // 提交任务给线程池执行 for (int i = 0; i < 10; i++) { executor.execute(new Task(i)); } // 关闭线程池 executor.shutdown(); } static class Task implements Runnable { private int taskId; public Task(int taskId) { this.taskId = taskId; } @Override public void run() { System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName()); } } }
在自定义线程池中，我们通过构造方法来设置线程池的参数，包括corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory和handler。通过合理地配置这些参数，我们可以创建出满足不同需求的线程池。
通过本文的介绍，相信你已经对Java中的线程池有了更深入的理解，并能够灵活地使用和自定义线程池来提高程序的并发性能。
