欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java Executor 框架的实例详解

程序员文章站 2024-02-28 15:48:40
java executor 框架的实例详解 大多数并发都是通过任务执行的方式来实现的。 一般有两种方式执行任务:串行和并行。 class singlethre...

java executor 框架的实例详解

大多数并发都是通过任务执行的方式来实现的。

一般有两种方式执行任务:串行和并行。

class singlethreadwebserver {
 public static void main(string[] args) throws exception {
  serversocket socket = new serversocket(80);
  while(true) {
   socket conn = socket.accept();
   handlerequest(conn);
  }
 }
}
class threadpertaskwebserver {
 public static void main(string[] args) throws exception {
  serversocket socket = new serversocket(80);
  while(true) {
   final socket conn = socket.accept();
   runnable task = new runnable() {
    public void run() {
     handlerequest(conn);
    }
   };
   new thread(task).start();
  }
 }
}

当然上面的这两种方式都是有问题的。单线程的问题就是并发量会是瓶颈,多线程版本就是无限制的创建线程会导致资源不足问题。

executor 框架

任务是一组逻辑工作单元,而线程是使任务异步执行的机制。

jdk 提供了 executor 接口:

public interface executor {
  void execute(runnable command);
}

虽然 executor 接口比较简单,但是却是异步任务执行框架的基础,该框架能支持多种不同类型的任务执行策略。它提供了一种标准的方式把任务的提交过程与执行过程进行了解耦。用 runnable 来代表任务。executor 的实现提供了对生命周期的支持以及统计信息应用程序管理等机制。

executor 是基于生产者消费者模式的,提交任务的操作相当于生产者,执行任务的线程相当于消费。

基于 executor 的 webserver 例子如下:

public class taskexecutorwebserver {
 private static final int nthreads = 100;
 private static final executor exec = executors.newfixedthreadpool(nthreads);
 public static void main(string[] args) throws exception {
  serversocket serversocket = new serversocket(80);
  while (true) {
   final socket conn = serversocket.accept();
   runnable task = new runnable() {
    @override
    public void run() {
     handlerequest(conn);
    }
   };
   exec.execute(task);
  }
 }
}

另外可以自己实现 executor 来控制是并发还是并行的,如下面代码:

/**
 * 执行已提交的 runnable 任务的对象。
 * 此接口提供一种将任务提交与每个任务将如何运行的机制(包括线程使用的细节、调度等)分离开来的方法。
 * 通常使用 executor 而不是显式地创建线程。
 *
 *
 * @author renchunxiao
 *
 */
public class executordemo {
 public static void main(string[] args) {
  executor executor = new threadexecutor();
  executor.execute(new runnable() {
   @override
   public void run() {
    // do something
   }
  });
  executor executor2 = new serialexecutor();
  executor2.execute(new runnable() {
   @override
   public void run() {
    // do something
   }
  });
 }
}
/**
 * 创建一个线程来执行 command
 *
 * @author renchunxiao
 *
 */
class threadexecutor implements executor {
 @override
 public void execute(runnable command) {
  new thread(command).start();
 }
}
/**
 * 串行执行 command
 *
 * @author renchunxiao
 *
 */
class serialexecutor implements executor {
 @override
 public void execute(runnable command) {
  command.run();
 }
}

线程池

线程池就是线程的资源池,可以通过 executors 中的静态工厂方法来创建线程池。

  • newfixedthreadpool。创建固定长度的线程池,每次提交任务创建一个线程,直到达到线程池的最大数量,线程池的大小不再变化。
  • newsinglethreadexecutor。单个线程池。
  • newcachedthreadpool。根据任务规模变动的线程池。
  • newscheduledthreadpool。创建固定长度的线程池,以延迟或定时的方式来执行任务。

jvm 只有在所有非守护线程全部终止后才会退出,所以,如果无法正确的关闭 executor,那么 jvm 就无法结束。

为了解决执行服务的生命周期问题,有个扩展 executor 接口的新接口 executorservice。

public interface executorservice extends executor {
 void shutdown();
 list<runnable> shutdownnow();
 boolean isshutdown();
 boolean isterminated();
 boolean awaittermination(long timeout, timeunit unit)
  throws interruptedexception;
 <t> future<t> submit(callable<t> task);
 <t> future<t> submit(runnable task, t result);
 future<?> submit(runnable task);
 <t> list<future<t>> invokeall(collection<? extends callable<t>> tasks)
  throws interruptedexception;
 <t> list<future<t>> invokeall(collection<? extends callable<t>> tasks,
         long timeout, timeunit unit)
  throws interruptedexception;
 <t> t invokeany(collection<? extends callable<t>> tasks)
  throws interruptedexception, executionexception;
 <t> t invokeany(collection<? extends callable<t>> tasks,
     long timeout, timeunit unit)
  throws interruptedexception, executionexception, timeoutexception;
}

executorservice 生命周期有三种状态:运行、关闭、已终止。executorservice 在初始创建时处于运行状态。shutdown 方法会平缓关闭:不在接受新的任务,并且等待已经执行的任务执行完成(包括那些还未开始的任务)。shutdownnow 方法将粗暴关闭:它将尝试取消所有运行中的任务,并且不再启动队列中尚未开始的任务。所有任务都执行完成后进入到已终止状态。

callable 和 future

executor 框架使用 runnable 作为基本的任务表示形式。runnable 是一种有局限性的抽象,它的 run 方法不能返回值和抛出一个受检查异常。

许多任务实际上是存在延时的计算,例如数据库查询,从网络获取资源。对于这些任务,callable 是更好的抽象,它认为 call 将返回一个值,并且可能抛出异常。

executor 执行的任务有四个生命周期阶段:创建、提交、开始和完成。由于有些任务需要很长时间有可能希望取消,在 executor 框架当中,已提交未开始的任务可以取消。

future 表示一个任务的生命周期,并且提供了相应的方法来判断是否已经完成或取消,以及获取任务的结果和取消任务等。

如有疑问请留言或者到本站社区交流讨论,感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!