设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java 线程池详解

2016-8-29 13:48| 发布者: zhangjf| 查看: 555| 评论: 0

摘要: 系统启动一个线程的成本是比较高的，因为它涉及到与操作系统的交互，使用线程池的好处是提高性能，当系统中包含大量并发的线程时，会导致系统性能剧烈下降，甚至导致JVM崩溃，而线程池的最大线程数参数可以控制系统 ...

系统启动一个线程的成本是比较高的，因为它涉及到与操作系统的交互，使用线程池的好处是提高性能，当系统中包含大量并发的线程时，会导致系统性能剧烈下降，甚至导致JVM崩溃，而线程池的最大线程数参数可以控制系统中并发线程数不超过次数。

一、Executors 工厂类用来产生线程池，该工厂类包含以下几个静态工厂方法来创建对应的线程池。创建的线程池是一个ExecutorService对象，使用该对象的submit方法或者是execute方法执行相应的Runnable或者是Callable任务。线程池本身在不再需要的时候调用shutdown()方法停止线程池，调用该方法后，该线程池将不再允许任务添加进来，但是会直到已添加的所有任务执行完成后才死亡。

1、newCachedThreadPool()，创建一个具有缓存功能的线程池，提交到该线程池的任务（Runnable或Callable对象）创建的线程，如果执行完成，会被缓存到CachedThreadPool中，供后面需要执行的任务使用。

  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  5. public class CacheThreadPool {
  6. static class Task implements Runnable {
  7. @Override
  8. public void run() {
  9. System.out.println(this + " " + Thread.currentThread().getName() + " AllStackTraces map size: "
  10. + Thread.currentThread().getAllStackTraces().size());
  11. }
  12. }
  14. public static void main(String[] args) {
  15. ExecutorService cacheThreadPool = Executors.newCachedThreadPool();
  17. //先添加三个任务到线程池
  18. for(int i = 0 ; i < 3; i++) {
  19. cacheThreadPool.execute(new Task());
  20. }
  22. //等三个线程执行完成后，再次添加三个任务到线程池
  23. try {
  24. Thread.sleep(3000);
  25. } catch (InterruptedException e) {
  26. e.printStackTrace();
  27. }
  29. for(int i = 0 ; i < 3; i++) {
  30. cacheThreadPool.execute(new Task());
  31. }
  32. }
  34. }
复制代码

执行结果如下：

  2. CacheThreadPool$Task@2d312eb9 pool-1-thread-1 AllStackTraces map size: 7
  3. CacheThreadPool$Task@59522b86 pool-1-thread-3 AllStackTraces map size: 7
  4. CacheThreadPool$Task@73dbb89f pool-1-thread-2 AllStackTraces map size: 7
  5. CacheThreadPool$Task@5795cedc pool-1-thread-3 AllStackTraces map size: 7
  6. CacheThreadPool$Task@256d5600 pool-1-thread-1 AllStackTraces map size: 7
  7. CacheThreadPool$Task@7d1c5894 pool-1-thread-2 AllStackTraces map size: 7
复制代码

线程池中的线程对象进行了缓存，当有新任务执行时进行了复用。但是如果有特别多的并发时，缓存线程池还是会创建很多个线程对象。

2、newFixedThreadPool(int nThreads) 创建一个指定线程个数，线程可复用的线程池。

  2. import java.util.concurrent.ExecutorService;
  3. import java.util.concurrent.Executors;
  5. public class FixedThreadPool {
  6. static class Task implements Runnable {
  7. @Override
  8. public void run() {
  9. System.out.println(this + " " + Thread.currentThread().getName() + " AllStackTraces map size: "
  10. + Thread.currentThread().getAllStackTraces().size());
  11. }
  12. }
  14. public static void main(String[] args) {
  15. ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
  17. // 先添加三个任务到线程池
  18. for (int i = 0; i < 5; i++) {
  19. fixedThreadPool.execute(new Task());
  20. }
  22. // 等三个线程执行完成后，再次添加三个任务到线程池
  23. try {
  24. Thread.sleep(3);
  25. } catch (InterruptedException e) {
  26. e.printStackTrace();
  27. }
  29. for (int i = 0; i < 3; i++) {
  30. fixedThreadPool.execute(new Task());
  31. }
  32. }
  34. }
复制代码

执行结果：

  2. FixedThreadPool$Task@7045c12d pool-1-thread-2 AllStackTraces map size: 7
  3. FixedThreadPool$Task@50fa0bef pool-1-thread-2 AllStackTraces map size: 7
  4. FixedThreadPool$Task@ccb1870 pool-1-thread-2 AllStackTraces map size: 7
  5. FixedThreadPool$Task@7392b4e3 pool-1-thread-1 AllStackTraces map size: 7
  6. FixedThreadPool$Task@5bdeff18 pool-1-thread-2 AllStackTraces map size: 7
  7. FixedThreadPool$Task@7d5554e1 pool-1-thread-1 AllStackTraces map size: 7
  8. FixedThreadPool$Task@24468092 pool-1-thread-3 AllStackTraces map size: 7
  9. FixedThreadPool$Task@fa7b978 pool-1-thread-2 AllStackTraces map size: 7
复制代码

3、newSingleThreadExecutor(),创建一个只有单线程的线程池，相当于调用newFixedThreadPool(1)

4、newSheduledThreadPool(int corePoolSize),创建指定线程数的线程池，它可以在指定延迟后执行线程。也可以以某一周期重复执行某一线程，知道调用shutdown()关闭线程池。

示例如下：

  2. import java.util.concurrent.Executors;
  3. import java.util.concurrent.ScheduledExecutorService;
  4. import java.util.concurrent.TimeUnit;
  6. public class ScheduledThreadPool {
  7. static class Task implements Runnable {
  8. @Override
  9. public void run() {
  10. System.out.println("time " + System.currentTimeMillis() + " " + Thread.currentThread().getName() + " AllStackTraces map size: "
  11. + Thread.currentThread().getAllStackTraces().size());
  12. }
  13. }
  15. public static void main(String[] args) {
  16. ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
  18. scheduledExecutorService.schedule(new Task(), 3, TimeUnit.SECONDS);
  20. scheduledExecutorService.scheduleAtFixedRate(new Task(), 3, 5, TimeUnit.SECONDS);
  22. try {
  23. Thread.sleep(30 * 1000);
  24. } catch (InterruptedException e) {
  25. e.printStackTrace();
  26. }
  27. scheduledExecutorService.shutdown();
  28. }
  30. }
复制代码

运行结果如下：

  2. time 1458921795240 pool-1-thread-1 AllStackTraces map size: 6
  3. time 1458921795241 pool-1-thread-2 AllStackTraces map size: 6
  4. time 1458921800240 pool-1-thread-1 AllStackTraces map size: 7
  5. time 1458921805240 pool-1-thread-1 AllStackTraces map size: 7
  6. time 1458921810240 pool-1-thread-1 AllStackTraces map size: 7
  7. time 1458921815240 pool-1-thread-1 AllStackTraces map size: 7
  8. time 1458921820240 pool-1-thread-1 AllStackTraces map size: 7
复制代码

由运行时间可看出，任务是按照5秒的周期执行的。

5、newSingleThreadScheduledExecutor() 创建一个只有一个线程的线程池，同调用newScheduledThreadPool(1)。

二、ForkJoinPool和ForkJoinTask

ForkJoinPool是ExecutorService的实现类，支持将一个任务划分为多个小任务并行计算，在把多个小任务的计算结果合并成总的计算结果。它有两个构造函数

ForkJoinPool(int parallelism)创建一个包含parallelism个并行线程的ForkJoinPool。

ForkJoinPool(),以Runtime.availableProcessors()方法返回值作为parallelism参数来创建ForkJoinPool。

ForkJoinTask 代表一个可以并行，合并的任务。它是实现了Future接口的抽象类，它有两个抽象子类，代表无返回值任务的RecuriveAction和有返回值的RecursiveTask。可根据具体需求继承这两个抽象类实现自己的对象，然后调用ForkJoinPool的submit 方法执行。

RecuriveAction 示例如下，实现并行输出0-300的数字。

  2. import java.util.concurrent.ForkJoinPool;
  3. import java.util.concurrent.RecursiveAction;
  4. import java.util.concurrent.TimeUnit;
  6. public class ActionForkJoinTask {
  7. static class PrintTask extends RecursiveAction {
  8. private static final int THRESHOLD = 50;
  9. private int start;
  10. private int end;
  12. public PrintTask(int start, int end) {
  13. this.start = start;
  14. this.end = end;
  15. }
  17. @Override
  18. protected void compute() {
  19. if (end - start < THRESHOLD) {
  20. for(int i = start; i < end; i++) {
  21. System.out.println(Thread.currentThread().getName() + " " + i);
  22. }
  23. } else {
  24. int middle = (start + end) / 2;
  25. PrintTask left = new PrintTask(start, middle);
  26. PrintTask right = new PrintTask(middle, end);
  27. left.fork();
  28. right.fork();
  29. }
  30. }
  32. }
  34. public static void main(String[] args) {
  35. ForkJoinPool pool = new ForkJoinPool();
  37. pool.submit(new PrintTask(0, 300));
  38. try {
  39. pool.awaitTermination(2, TimeUnit.SECONDS);
  40. } catch (InterruptedException e) {
  41. e.printStackTrace();
  42. }
  44. pool.shutdown();
  45. }
  47. }
复制代码

在拆分小任务后，调用任务的fork（）方法，加入到ForkJoinPool中并行执行。

RecursiveTask示例，实现并行计算100个整数求和。拆分为每20个数求和后获取结果，在最后合并为最后的结果。

  2. import java.util.Random;
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.ForkJoinPool;
  5. import java.util.concurrent.Future;
  6. import java.util.concurrent.RecursiveTask;
  8. public class TaskForkJoinTask {
  9. static class CalTask extends RecursiveTask<Integer> {
  10. private static final int THRESHOLD = 20;
  12. private int arr[];
  13. private int start;
  14. private int end;
  16. public CalTask(int[] arr, int start, int end) {
  17. this.arr = arr;
  18. this.start = start;
  19. this.end = end;
  20. }
  22. @Override
  23. protected Integer compute() {
  24. int sum = 0;
  26. if (end - start < THRESHOLD) {
  27. for (int i = start; i < end; i++) {
  28. sum += arr[i];
  29. }
  30. System.out.println(Thread.currentThread().getName() + " sum:" + sum);
  31. return sum;
  32. } else {
  33. int middle = (start + end) / 2;
  34. CalTask left = new CalTask(arr, start, middle);
  35. CalTask right = new CalTask(arr, middle, end);
  37. left.fork();
  38. right.fork();
  40. return left.join() + right.join();
  41. }
  42. }
  44. }
  46. public static void main(String[] args) {
  47. int arr[] = new int[100];
  48. Random random = new Random();
  49. int total = 0;
  51. for (int i = 0; i < arr.length; i++) {
  52. int tmp = random.nextInt(20);
  53. total += (arr[i] = tmp);
  54. }
  55. System.out.println("total " + total);
  57. ForkJoinPool pool = new ForkJoinPool(4);
  59. Future<Integer> future = pool.submit(new CalTask(arr, 0, arr.length));
  60. try {
  61. System.out.println("cal result: " + future.get());
  62. } catch (InterruptedException e) {
  63. e.printStackTrace();
  64. } catch (ExecutionException e) {
  65. e.printStackTrace();
  66. }
  67. pool.shutdown();
  68. }
  70. }
复制代码

执行结果如下：

  2. total 912
  3. ForkJoinPool-1-worker-2 sum:82
  4. ForkJoinPool-1-worker-2 sum:123
  5. ForkJoinPool-1-worker-2 sum:144
  6. ForkJoinPool-1-worker-3 sum:119
  7. ForkJoinPool-1-worker-2 sum:106
  8. ForkJoinPool-1-worker-2 sum:128
  9. ForkJoinPool-1-worker-2 sum:121
  10. ForkJoinPool-1-worker-3 sum:89
  11. cal result: 912
复制代码

子任务执行完后，调用任务的join（）方法获取子任务执行结果，再相加获得最后的结果。

收藏 邀请
上一篇：基于遗传算法的优化问题求解下一篇：Java ArrayDeque使用方法详解

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-8 00:40

Copyright 2015-2025 djqfx

返回顶部