国内企业网站建设,西安比较好的网络公司,毕业设计网站可以做什么,北京网站的建立的1、使用Executors工厂方法#xff1a;
使用Executors工厂方法创建线程池是一种简单快捷的方式#xff0c;适用于一些常见的线程池需求。以下是几个示例#xff0c;演示如何使用Executors工厂方法创建不同类型的线程池#xff1a;
固定大小线程池 (newFixedThreadPool)
使用Executors工厂方法创建线程池是一种简单快捷的方式适用于一些常见的线程池需求。以下是几个示例演示如何使用Executors工厂方法创建不同类型的线程池
固定大小线程池 (newFixedThreadPool)
这种类型的线程池会一直保持固定数量的线程在池中不会自动回收线程。适用于需要限制同时执行的任务数量的场景。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class FixedThreadPoolExample {public static void main(String[] args) {int numThreads 5;ExecutorService executor Executors.newFixedThreadPool(numThreads);// 提交任务到线程池for (int i 0; i 10; i) {executor.submit(new MyRunnable(i));}executor.shutdown(); // 关闭线程池}
}缓存线程池 (newCachedThreadPool)
缓存线程池会根据需要创建新的线程如果线程池中的线程空闲时间超过指定的时间则会被回收。适用于任务数量不确定且需要自动调整线程数的场景。
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.submit(new MyRunnable(i));}executor.shutdown(); // 关闭线程池}
}单线程线程池 (newSingleThreadExecutor)
单线程线程池只有一个工作线程适用于需要按顺序执行任务的场景。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class SingleThreadExecutorExample {public static void main(String[] args) {ExecutorService executor Executors.newSingleThreadExecutor();// 提交任务到线程池for (int i 0; i 10; i) {executor.submit(new MyRunnable(i));}executor.shutdown(); // 关闭线程池}
}定时任务线程池 (newScheduledThreadPool)
定时任务线程池用于执行定时任务和周期性任务。
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;public class ScheduledThreadPoolExample {public static void main(String[] args) {int numThreads 3;ScheduledExecutorService executor Executors.newScheduledThreadPool(numThreads);// 延迟1秒后执行任务executor.schedule(new MyRunnable(1), 1, TimeUnit.SECONDS);// 延迟2秒后每3秒执行一次任务executor.scheduleAtFixedRate(new MyRunnable(2), 2, 3, TimeUnit.SECONDS);// 关闭线程池executor.shutdown();}
}在这些示例中MyRunnable是一个实现了Runnable接口的自定义任务类。创建线程池后使用submit方法将任务提交给线程池进行执行并最终调用shutdown方法关闭线程池。
这些Executors工厂方法提供了一些常见的线程池类型但在某些情况下可能需要更精细的线程池配置这时可以考虑手动创建ThreadPoolExecutor。
2、手动创建ThreadPoolExecutor
手动创建 ThreadPoolExecutor 允许对线程池的各种参数进行更精细的配置以满足特定的需求。以下是一个示例演示如何手动创建 ThreadPoolExecutor
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class ManualThreadPoolExecutorExample {public static void main(String[] args) {int corePoolSize 5;int maxPoolSize 10;long keepAliveTime 60; // 60秒TimeUnit timeUnit TimeUnit.SECONDS;BlockingQueueRunnable workQueue new LinkedBlockingQueue();ThreadPoolExecutor executor new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveTime, timeUnit, workQueue);// 提交任务到线程池for (int i 0; i 10; i) {executor.submit(new MyRunnable(i));}executor.shutdown(); // 关闭线程池}
}class MyRunnable implements Runnable {private int id;public MyRunnable(int id) {this.id id;}Overridepublic void run() {System.out.println(Task id is running on thread Thread.currentThread().getName());}
}在这个示例中手动创建了一个 ThreadPoolExecutor并配置了核心线程数、最大线程数、线程空闲时间等参数。然后使用 submit 方法将任务提交给线程池进行执行并最终调用 shutdown 方法关闭线程池。
注意BlockingQueue 参数用于指定任务队列用来存储等待执行的任务。在这里使用了 LinkedBlockingQueue也可以选择其他的实现如 ArrayBlockingQueue、PriorityBlockingQueue 等以适应不同的需求。
手动创建 ThreadPoolExecutor 允许更精细地控制线程池的行为但也需要更多的配置和管理。在选择线程池类型和参数时应根据应用的特性和需求进行调整。
3、使用ForkJoinPool
ForkJoinPool 是 Java 提供的用于支持分治任务的线程池实现。它特别适用于能够将任务拆分成更小的子任务并且这些子任务可以并行执行的情况。以下是一个使用 ForkJoinPool 创建线程池的示例
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;public class ForkJoinPoolExample {public static void main(String[] args) {ForkJoinPool forkJoinPool new ForkJoinPool();MyRecursiveAction task new MyRecursiveAction(0, 10);forkJoinPool.invoke(task);forkJoinPool.shutdown();}
}class MyRecursiveAction extends RecursiveAction {private static final int THRESHOLD 2; // 阈值小于该值就不再分解任务private int start;private int end;public MyRecursiveAction(int start, int end) {this.start start;this.end end;}Overrideprotected void compute() {if (end - start THRESHOLD) {// 执行任务逻辑for (int i start; i end; i) {System.out.println(Task is running on thread Thread.currentThread().getName() : i);}} else {// 分解任务int mid (start end) / 2;MyRecursiveAction left new MyRecursiveAction(start, mid);MyRecursiveAction right new MyRecursiveAction(mid 1, end);invokeAll(left, right);}}
}在这个示例中首先创建了一个 ForkJoinPool 实例然后定义了一个继承自 RecursiveAction 的 MyRecursiveAction 类用于表示要执行的分治任务。在 compute 方法中首先检查任务是否足够小如果是则执行任务逻辑否则将任务分解为两个子任务并使用 invokeAll 方法并行执行。
ForkJoinPool 会根据任务的大小和可用线程数来动态地调度任务的执行以获得最佳的并行性能。在实际使用中可以根据任务的特性和复杂度调整阈值以及分解和执行子任务的逻辑。
注意ForkJoinPool 适用于能够利用分治并行计算的场景如递归问题的解决和并行计算任务。
4、使用 ScheduledThreadPoolExecutor 类
ScheduledThreadPoolExecutor 是 ThreadPoolExecutor 的子类专门用于创建带有定时任务功能的线程池。它可以执行定时任务和周期性任务。以下是一个使用 ScheduledThreadPoolExecutor 创建线程池的示例
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;public class ScheduledThreadPoolExecutorExample {public static void main(String[] args) {int numThreads 3;ScheduledExecutorService executor Executors.newScheduledThreadPool(numThreads);// 延迟1秒后执行任务executor.schedule(new MyRunnable(1), 1, TimeUnit.SECONDS);// 延迟2秒后每3秒执行一次任务executor.scheduleAtFixedRate(new MyRunnable(2), 2, 3, TimeUnit.SECONDS);// 关闭线程池executor.shutdown();}
}class MyRunnable implements Runnable {private int id;public MyRunnable(int id) {this.id id;}Overridepublic void run() {System.out.println(Task id is running on thread Thread.currentThread().getName());}
}在这个示例中使用 Executors.newScheduledThreadPool() 方法创建了一个 ScheduledExecutorService然后使用 schedule 方法在指定的延迟时间后执行一次任务使用 scheduleAtFixedRate 方法在指定的延迟时间后开始执行任务并且每隔一段时间重复执行。
ScheduledThreadPoolExecutor 可以满足定时任务和周期性任务的需求它能够自动调度任务的执行。当任务执行时间超过任务间隔时间时ScheduledThreadPoolExecutor 会等待当前任务完成后再启动下一个任务。这种特性对于需要保证任务执行间隔的场景非常有用。
5、使用第三方库如ThreadPoolExecutor的封装库
许多第三方库都提供了对 ThreadPoolExecutor 的封装以便更方便地创建和管理线程池。其中一个常用的库是 Apache Commons Lang 中的 ThreadPoolExecutor它提供了一些额外的功能和配置选项。以下是一个使用 Apache Commons Lang 的 ThreadPoolExecutor 封装库的示例
首先确保已经将 Apache Commons Lang 库添加到项目中。然后你可以使用 org.apache.commons.lang3.concurrent.BasicThreadFactory 来创建线程池。下面是示例代码
import org.apache.commons.lang3.concurrent.BasicThreadFactory;import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class ThirdPartyThreadPoolExample {public static void main(String[] args) {int numThreads 3;BasicThreadFactory factory new BasicThreadFactory.Builder().namingPattern(my-pool-%d).daemon(true).build();ScheduledExecutorService executor new ScheduledThreadPoolExecutor(numThreads, factory);// 延迟1秒后执行任务executor.schedule(new MyRunnable(1), 1, TimeUnit.SECONDS);// 延迟2秒后每3秒执行一次任务executor.scheduleAtFixedRate(new MyRunnable(2), 2, 3, TimeUnit.SECONDS);// 关闭线程池executor.shutdown();}
}class MyRunnable implements Runnable {private int id;public MyRunnable(int id) {this.id id;}Overridepublic void run() {System.out.println(Task id is running on thread Thread.currentThread().getName());}
}在这个示例中使用 BasicThreadFactory 来配置线程池。通过设置不同的属性可以定制线程名、守护线程属性等。然后使用 ScheduledThreadPoolExecutor 创建一个带有定时任务功能的线程池并使用 schedule 和 scheduleAtFixedRate 方法添加定时任务。
使用第三方库的线程池封装可以帮助更方便地创建和管理线程池以及提供一些额外的功能选项。
