Java四种线程池的使用以及callable future整理

最新推荐文章于 2024-08-14 11:01:54 发布
最新推荐文章于 2024-08-14 11:01:54 发布
阅读量1.3k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anbangcsdn/article/details/51192538
版权
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

(1) newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

  1. package test;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class ThreadPoolExecutorTest {  
  5.  public static void main(String[] args) {  
  6.   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
  7.   for (int i = 0; i < 10; i++) {  
  8.    final int index = i;  
  9.    try {  
  10.     Thread.sleep(index * 1000);  
  11.    } catch (InterruptedException e) {  
  12.     e.printStackTrace();  
  13.    }  
  14.    cachedThreadPool.execute(new Runnable() {  
  15.     public void run() {  
  16.      System.out.println(index);  
  17.     }  
  18.    });  
  19.   }  
  20.  }  
  21. }

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
 
(2) newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

Java代码   收藏代码
  1. package test;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class ThreadPoolExecutorTest {  
  5.  public static void main(String[] args) {  
  6.   ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
  7.   for (int i = 0; i < 10; i++) {  
  8.    final int index = i;  
  9.    fixedThreadPool.execute(new Runnable() {  
  10.     public void run() {  
  11.      try {  
  12.       System.out.println(index);  
  13.       Thread.sleep(2000);  
  14.      } catch (InterruptedException e) {  
  15.       e.printStackTrace();  
  16.      }  
  17.     }  
  18.    });  
  19.   }  
  20.  }  
  21. }  
 
因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

(3)  newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

Java代码   收藏代码
  1. package test;  
  2. import java.util.concurrent.Executors;  
  3. import java.util.concurrent.ScheduledExecutorService;  
  4. import java.util.concurrent.TimeUnit;  
  5. public class ThreadPoolExecutorTest {  
  6.  public static void main(String[] args) {  
  7.   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  8.   scheduledThreadPool.schedule(new Runnable() {  
  9.    public void run() {  
  10.     System.out.println("delay 3 seconds");  
  11.    }  
  12.   }, 3, TimeUnit.SECONDS);  
  13.  }  
  14. }  

 
表示延迟3秒执行。

定期执行示例代码如下：

  1. package test;  
  2. import java.util.concurrent.Executors;  
  3. import java.util.concurrent.ScheduledExecutorService;  
  4. import java.util.concurrent.TimeUnit;  
  5. public class ThreadPoolExecutorTest {  
  6.  public static void main(String[] args) {  
  7.   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  8.   scheduledThreadPool.scheduleAtFixedRate(new Runnable() {  
  9.    public void run() {  
  10.     System.out.println("delay 1 seconds, and excute every 3 seconds");  
  11.    }  
  12.   }, 1, 3, TimeUnit.SECONDS);  
  13.  }  
  14. }  

 
表示延迟1秒后每3秒执行一次。

 

(4) newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

Java代码   收藏代码
  1. package test;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class ThreadPoolExecutorTest {  
  5.  public static void main(String[] args) {  
  6.   ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
  7.   for (int i = 0; i < 10; i++) {  
  8.    final int index = i;  
  9.    singleThreadExecutor.execute(new Runnable() {  
  10.     public void run() {  
  11.      try {  
  12.       System.out.println(index);  
  13.       Thread.sleep(2000);  
  14.      } catch (InterruptedException e) {  
  15.       e.printStackTrace();  
  16.      }  
  17.     }  
  18.    });  
  19.   }  
  20.  }  
  21. }  

 
结果依次输出，相当于顺序执行各个任务。

你可以使用JDK自带的监控工具来监控我们创建的线程数量，运行一个不终止的线程，创建指定量的线程，来观察：
工具目录：C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe
运行程序做稍微修改：

Java代码   收藏代码
  1. package test;  
  2. import java.util.concurrent.ExecutorService;  
  3. import java.util.concurrent.Executors;  
  4. public class ThreadPoolExecutorTest {  
  5.  public static void main(String[] args) {  
  6.   ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();  
  7.   for (int i = 0; i < 100; i++) {  
  8.    final int index = i;  
  9.    singleThreadExecutor.execute(new Runnable() {  
  10.     public void run() {  
  11.      try {  
  12.       while(true) {  
  13.        System.out.println(index);  
  14.        Thread.sleep(10 * 1000);  
  15.       }  
  16.      } catch (InterruptedException e) {  
  17.       e.printStackTrace();  
  18.      }  
  19.     }  
  20.    });  
  21.    try {  
  22.     Thread.sleep(500);  
  23.    } catch (InterruptedException e) {  
  24.     e.printStackTrace();  
  25.    }  
  26.   }  
  27.  }  
  28. }  

 
效果如下：

 

选择我们运行的程序：

监控运行状态

 

转载自：http://cuisuqiang.iteye.com/blog/2019372    

http://blog.csdn.net/hupitao/article/details/24453083

 Callable接口类似于Runnable，从名字就可以看出来了，但是Runnable不会返回结果，并且无法抛出返回结果的异常，而Callable功能更强大一些，被线程执行后，可以返回值，这个返回值可以被Future拿到，也就是说，Future可以拿到异步执行任务的返回值，下面来看一个简单的例子：

<code class="hljs cs has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> CallableAndFuture {
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span>(String[] args) {
        Callable<Integer> callable = <span class="hljs-keyword">new</span> Callable<Integer>() {
            <span class="hljs-keyword">public</span> Integer <span class="hljs-title">call</span>() throws Exception {
                <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> Random().nextInt(<span class="hljs-number">100</span>);
            }
        };
        FutureTask<Integer> future = <span class="hljs-keyword">new</span> FutureTask<Integer>(callable);
        <span class="hljs-keyword">new</span> Thread(future).start();
        <span class="hljs-keyword">try</span> {
            Thread.sleep(<span class="hljs-number">5000</span>);<span class="hljs-comment">// 可能做一些事情</span>
            System.<span class="hljs-keyword">out</span>.println(future.<span class="hljs-keyword">get</span>());
        } <span class="hljs-keyword">catch</span> (InterruptedException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">catch</span> (ExecutionException e) {
            e.printStackTrace();
        }
    }
}</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li></ul>

       FutureTask实现了两个接口，Runnable和Future，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值，那么这个组合的使用有什么好处呢？假设有一个很耗时的返回值需要计算，并且这个返回值不是立刻需要的话，那么就可以使用这个组合，用另一个线程去计算返回值，而当前线程在使用这个返回值之前可以做其它的操作，等到需要这个返回值时，再通过Future得到，岂不美哉！这里有一个Future模式的介绍：http://openhome.cc/Gossip/DesignPattern/FuturePattern.htm。
       下面来看另一种方式使用Callable和Future，通过ExecutorService的submit方法执行Callable，并返回Future，代码如下：

<code class="hljs cs has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> CallableAndFuture {
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span>(String[] args) {
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        Future<Integer> future = threadPool.submit(<span class="hljs-keyword">new</span> Callable<Integer>() {
            <span class="hljs-keyword">public</span> Integer <span class="hljs-title">call</span>() throws Exception {
                <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> Random().nextInt(<span class="hljs-number">100</span>);
            }
        });
        <span class="hljs-keyword">try</span> {
            Thread.sleep(<span class="hljs-number">5000</span>);<span class="hljs-comment">// 可能做一些事情</span>
            System.<span class="hljs-keyword">out</span>.println(future.<span class="hljs-keyword">get</span>());
        } <span class="hljs-keyword">catch</span> (InterruptedException e) {
            e.printStackTrace();
        } <span class="hljs-keyword">catch</span> (ExecutionException e) {
            e.printStackTrace();
        }
    }
}</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li></ul>

       代码是不是简化了很多，ExecutorService继承自Executor，它的目的是为我们管理Thread对象，从而简化并发编程，Executor使我们无需显示的去管理线程的生命周期，是JDK 5之后启动任务的首选方式。
       执行多个带返回值的任务，并取得多个返回值，代码如下：

<code class="hljs cs has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> CallableAndFuture {
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">main</span>(String[] args) {
        ExecutorService threadPool = Executors.newCachedThreadPool();
        CompletionService<Integer> cs = <span class="hljs-keyword">new</span> ExecutorCompletionService<Integer>(threadPool);
        <span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i = <span class="hljs-number">1</span>; i < <span class="hljs-number">5</span>; i++) {
            final <span class="hljs-keyword">int</span> taskID = i;
            cs.submit(<span class="hljs-keyword">new</span> Callable<Integer>() {
                <span class="hljs-keyword">public</span> Integer <span class="hljs-title">call</span>() throws Exception {
                    <span class="hljs-keyword">return</span> taskID;
                }
            });
        }
        <span class="hljs-comment">// 可能做一些事情</span>
        <span class="hljs-keyword">for</span>(<span class="hljs-keyword">int</span> i = <span class="hljs-number">1</span>; i < <span class="hljs-number">5</span>; i++) {
            <span class="hljs-keyword">try</span> {
                System.<span class="hljs-keyword">out</span>.println(cs.take().<span class="hljs-keyword">get</span>());
            } <span class="hljs-keyword">catch</span> (InterruptedException e) {
                e.printStackTrace();
            } <span class="hljs-keyword">catch</span> (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
} </code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li></ul>

       其实也可以不使用CompletionService，可以先创建一个装Future类型的集合，用Executor提交的任务返回值添加到集合中，最后遍历集合取出数据，代码略。更新于2016-02-05，评论中就这个说法引发了讨论，其实是我没有讲清楚，抱歉。这里再阐述一下：提交到CompletionService中的Future是按照完成的顺序排列的，这种做法中Future是按照添加的顺序排列的。所以这两种方式的区别就像评论中fishjam所描述的那样。

       本文来自：高爽|Coder，原文地址：http://blog.csdn.net/ghsau/article/details/7451464，转载请注明。

Java并发编程：Callable、Future和FutureTask详情介绍

http://www.cnblogs.com/dolphin0520/p/3949310.html

http://www.cnblogs.com/starcrm/p/5010863.html

索取者
关注
JAVA 线程池之Callable返回结果
m0_68850571的博客
04-17 1671
本文介绍如何向线程池提交任务，并获得任务的执行结果。然后模拟 线程池中的线程在执行任务的过程中抛出异常时，该如何处理。 一，执行具体任务的线程类 要想 获得 线程的执行结果，需实现Callable接口。FactorialCalculator 计算 number的阶乘，具体实现如下： 1 import java.util.concurrent.Callable; 2 import java.util.concurrent.TimeUnit; 3 4 /** 5 * Created by
java通过Callable和Future来接收线程池的执行结果
08-25
主要介绍了java通过Callable和Future来接收线程池的执行结果，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java线程池（Callable+Future模式）
weixin_30770783的博客
11-14 247
Java线程池（Callable+Future模式） Java通过Executors提供四种线程池 1)newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 2)newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 3)newScheduledThreadP...
Java高效并发编程：深入探索ExecutorService与Future
最新发布
运维人生
08-14 354
是Java提供的用于管理线程池的工具类，它允许开发者以任务（Runnable或Callable）的形式提交给线程池执行，而无需直接创建和管理线程。通过抽象层隔离了任务提交与任务执行的具体细节，使得并发编程更加简洁、高效。与Future的结合使用，为Java并发编程提供了强大的异步任务执行与结果管理能力。通过，我们可以灵活控制线程池的大小，避免了直接创建和管理线程的复杂性；而Future则让我们能够非阻塞地获取异步任务的结果，提高了程序的响应性和吞吐量。在实际应用中，合理使用和Future。
Java多线程4--线程池--Callable方法
chencaw的专栏
08-24 2032
1、主要流程、 例子如下 package chen.thread.demo2; import java.util.concurrent.*; public class TestCallThread implements Callable<Boolean> { private String name; public TestCallThread(String name){ this.name = name; } @Over.
[Java学习]Java线程池（Callable+Future模式）
weixin_45329445的博客
09-04 275
转载文章：https://www.cnblogs.com/myxcf/p/9959870.html Java通过Executors提供四种线程池 1).newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 2).newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 3).newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。 4).new
JAVA并行异步编程线程池+FutureTask
u013334626的专栏
08-25 1236
java 在JDK1.5中引入一个新的并发包java.util.concurrent 该包专门为java处理并发而书写。 在java中熟悉的使用多线程的方式为两种？继续Thread类，实现Runnale。两种方式简单方便。 在Jdk1.5之后其实有第三种方式实现方式，采用并发包中的Callable接口 FuruteTask类 以及ExecutorService接口。   说
Java concurrency线程池之Callable和Future_动力节点Java学院整理
08-30
Java concurrency线程池之Callable和Future Java concurrency是一个重要的概念，在Java编程中，线程池是一个关键组件。今天，我们将详细介绍Java concurrency线程池之Callable和Future，这两个组件在Java并发编程中...
Java线程--线程池Future、Callable
mmlz00的博客
11-20 181
Future、Callable配套使用 Runnable与Callable区别： Runnable接口： 一个独立的任务，任务执行的结果，无需告知主线程 Runnable接口中的方法为：void run(){} Callable接口： 也是一个独立的任务，但是任务执行的结果，是主线程想要知晓的，因此可以配套Future接口，在将来的某个时间点，主线程可以获取到独立任务的执行结果，以便主...
浅谈在Java中使用Callable、Future进行并行编程
08-28
从Java 1.5开始，引入了Callable和Future接口，为并行编程提供了一种更为高效和便捷的解决方案。 Callable接口是Java并发库中的一个关键接口，位于`java.util.concurrent`包下。Callable接口与Runnable接口类似，但...
java callable 线程池 future
wxynj的博客
05-28 210
public class MyThread implements Callable<String> { private String name; private int waittime; @Override public String call() throws Exception { log.info("mythread ...
理解Java中的线程组、线程池和Callable接口
胡啊呦的博客
07-17 625
线程组 线程组概述 线程池 为什么会有线程池？（线程池概述） 内置线程池 Future 接口 实现多线程的第三种方式 线程组 线程组概述 Java中用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。 默认情况下，所有的线程都属于主线程组。 public final ThreadGroup getThrea...
JAVA基础 线程池、callable
alexzt的博客
05-02 187
package demo; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class ExecutorDemo {...
Java线程 (使用Callable实现多线程)，看完你发现多线程多么简单！
bq520111的博客
03-29 902
还有更多的Redis、MySQL、JVM、Kafka、微服务、Spring全家桶等学习笔记这里就不一一列举出来。
JAVA多线程—Callable详解
热门推荐
m0_61160520的博客
07-10 1万+
Callable作为除Thread和Runnable外第三种线程创建方式， - Callable提高响应速度（减少了创建新线程的时间） - Callable降低资源消耗（重复利用线程池中线程，不需要每次都创建） - Callable便于线程管理
Java 多线程 线程池处理Callable请求
zhanghe_zht的博客
06-08 182
Callable请求有返回值，而Runnable请求没有返回值 可以利用Future接收返回值 继承Callable的执行类： class GetUserInfo implements Callable{ private String id; GetUserInfo(String id){ this.id = id; } @Override public Object call() throws Exception { UserIn
Java多线程3-线程池、Callable和Future
undoner
11-02 2513
线程池        java.util.concurrent，在Java开发中，我们接触到了好多池的技术，String类的对象池、Integer的共享池、连接数据库的连接池、Struts1.3的对象池等等，池的最终目的都是节约资源，以更小的开销做更多的事情，从而提高性能。         我们的web项目都是部署在服务器上，浏览器端的每一个request就是一个线程，那么服务器需要并发的
java并发----java线程池，Executor框架，Callable，Future
人在江湖
06-09 777
前言 本文章适合新手对线程池的认识=0的同学，不涉及源码，仅从应用层次来讲，是笔者的资料整理，每一个都有相应的实例 主要内容 线程池的类型，区别，特点 线程池如何提交runnable任务和callable任务。 线程池所使用的队列（有界，无界） 线程池满的策略 自定义线程 why？ 其实每次学习一个新知识的时候，我们都需要知道为什么要使用它？ 通俗概括： 创建线程T1时间，线...
Java线程池详解：Future的使用和实现
bjmsb79的博客
07-07 2231
java复制代码public class FutureTask implements RunnableFuture { // 为Callable任务生成FutureTask public FutureTask(Callable callable) { if (callable == null) throw new NullPointerException();
java future callable
妖君你好的博客
08-26 442
有个需求，数据库有两个字段，ip和端口。是很多其他数据库的地址。现在需要下载这些数据库的数据 之前的做法是 while(true){ 数据库读出一行为下载的数据 下载数据 } 但是下载数据的时候可能会假死，然后线程阻塞了。除非重启继续下载。 现在采用future和callable来配合下载。 callable来下载数据。 future来控制流程。 publi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值