Netty进阶之EventExecutorGroup源码详解

 更新时间:2023年11月16日 10:44:19   作者:立小研先森  
这篇文章主要介绍了Netty进阶之EventExecutorGroup源码详解,EventExecutorGroup继承了JDK的ScheduledExecutroService,那么它就拥有了执行定时任务,执行提交的普通任务,需要的朋友可以参考下

前言

EventExecutorGroup继承了JDK的ScheduledExecutroService,那么它就拥有了执行定时任务,执行提交的普通任务;

EventExecutorGroup还继承了JDK的Iterable接口,表示EventExecutorGroup是可遍历的,它的遍历对象是EventExecutor;

一、Iterable相关方法

EventExecutorGroup中有两个Iterable相关的方法:

    //返回一个被当前EventExecutorGroup管理的EventExecutor对象
		EventExecutor next();
    //返回一个EventExecutor类型的迭代器
    @Override
    Iterator<EventExecutor> iterator();

二、execute

接口Executor提供了一个提交执行任务的方法execute

    //返回一个被当前EventExecutorGroup管理的EventExecutor对象
		EventExecutor next();
    //返回一个EventExecutor类型的迭代器
    @Override
    Iterator<EventExecutor> iterator();

三、Executor的子接口ExecutorService

public interface ExecutorService extends Executor {

    /**
     * 启动有序关闭,在关闭过程中会继续执行以前提交的任务,但是不接受新的任务
     */
    void shutdown();

    /**
     * 尝试停止所有正在执行的任务,停止处理等待的任务,并返回一个等待执行的任务列表
     */
    List<Runnable> shutdownNow();

    /**
     * 如果此执行程序已关闭,则返回true
     */
    boolean isShutdown();

    /**
     * 如果关闭后所有任务都已完成,则返回true
     * 只有首先调用了shutdown()、shutdownNow()方法才有可能返回true,否则一定为false
     */
    boolean isTerminated();

    /**
     * 阻塞,shutdown后所有任务执行完成、超时、当前线程被终端,那个先发生那个优先;
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 提交一个带返回值的执行任务,并返回一个Future代表将要返回的任务结果
     */
    <T> Future<T> submit(Callable<T> task);

    /**
     * 提交一个可运行任务以供执行,并返回一个表示该任务的Future。Future的get方法将在成功完成后返回给定的结果。
     */
    <T> Future<T> submit(Runnable task, T result);

    /**
     * 提交一个可运行任务以供执行,并返回一个表示该任务的Future。Future的get方法在成功完成后将返回null。
     */
    Future<?> submit(Runnable task);

    /**
     * 执行给定的多个任务,返回一个持有执行状态和结果的Future列表。
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    /**
     * 执行给定的多个任务,返回一个持有执行状态和结果的Future列表。
     * 当所有的任务完成或超时过期Future#isDone都将返回ture
     */
    <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;
}

下面是一个网络服务案例,其中线程池中的线程为传入请求提供服务,它使用预先配置的Executors.newFixedThreadPool工厂方法:

class NetworkService implements Runnable {
    private final ServerSocket serverSocket;
    private final ExecutorService pool;

    public NetworkService(int port, int poolSize) throws IOException {
        serverSocket = new ServerSocket(port);
        pool = Executors.newFixedThreadPool(poolSize);
    }

    public void run() { // run the service      
        try {
            for (; ; ) {
                pool.execute(new Handler(serverSocket.accept()));
            }
        } catch (IOException ex) {
            pool.shutdown();
        }
    }
}

class Handler implements Runnable {
    private final Socket socket;

    Handler(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        // read and service request on socket   
    }
}

下面的方法关闭ExecutorService分两个阶段,首先通过调用shutdown方法拒绝新任务进来,然后调用shutdownNow,如果有必要取消任何延迟任务:

    void shutdownAndAwaitTermination(ExecutorService pool) {
        pool.shutdown(); // Disable new tasks from being submitted    
        try {
            // Wait a while for existing tasks to terminate      
            if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                pool.shutdownNow(); // Cancel currently executing tasks        
                // Wait a while for tasks to respond to being cancelled      
                if (!pool.awaitTermination(60, TimeUnit.SECONDS))
                    System.err.println("Pool did not terminate");
            }
        } catch (InterruptedException ie) {
            // (Re-)Cancel if current thread also interrupted      
            pool.shutdownNow();      // Preserve interrupt status     
            Thread.currentThread().interrupt();
        }
    }

四、ExecutorService的子接口ScheduledExecutorService

ScheduledExecutorService接口提供了四个新的方法schedule延迟指定的时间执行任务,scheduleAtFixedRate方法延迟指定时间、按照固定的时间频率执行任务。

public interface ScheduledExecutorService extends ExecutorService {
    /**
     * 提交一个一次性任务,该任务在给定延迟后变为启用状态。
     *
     * @param command 要执行的任务
     * @param delay 从现在开始延迟执行的时间
     * @param unit delay参数的时间单位
     * @return 一个ScheduledFuture,标识任务的挂起完成,其get方法将在完成时返回null
     */
    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);
    /**
     * 提交一个带返回值的一次性任务,该任务在给定延迟后变为启用状态
     *
     * @param callable 要执行的函数任务
     * @param delay 从现在开始延迟执行的时间
     * @param unit delay参数的时间单位
     * @param <V> the type of the callable's result
     * @return 可用于提取结果或取消的ScheduledFuture
     */
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);
    /**
     * 提交一个可执行任务,延迟指定时间,然后按照period时间间隔执行任务
     */
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);
    /**
     * 提交一个可执行任务,延迟指定时间,然后按照period时间间隔执行任务
     */
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);
}

五、ScheduledExecutorService的子接口EventExecutorGroup

EventExecutorGroup新增了三个方法:

  • isShuttingDown:当且仅当此EventExecutorGroup管理的所有EventExecutor正在正常关闭或已关闭时,返回true
  • shutdownGracefully:指定了超时时间的优雅关闭方法;

到此这篇关于Netty进阶之EventExecutorGroup源码详解的文章就介绍到这了,更多相关EventExecutorGroup源码详解内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • java中如何反射获取一个类

    java中如何反射获取一个类

    大家说说对java反射的理解,使用反射如何获取一个类,下面小编给大家整理一些资料,关于java中如何反射获取一个类,有需要的朋友可以参考下
    2015-08-08
  • 详解Java如何实现有效的并发处理

    详解Java如何实现有效的并发处理

    随着互联网的蓬勃发展,现代软件系统对于并发性能的要求越来越高,如何学习和掌握并发编程技术成为了Java开发人员必备的技能之一,本文主要介绍了Java并发编程的相关概念、原理和实践技巧,感兴趣的可以了解下
    2023-11-11
  • Spring Boot FeignClient 如何捕获业务异常信息

    Spring Boot FeignClient 如何捕获业务异常信息

    这篇文章主要介绍了Spring Boot FeignClient 如何捕获业务异常信息的操作,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-06-06
  • Java中HashTable和HashMap的区别_动力节点Java学院整理

    Java中HashTable和HashMap的区别_动力节点Java学院整理

    HashTable和HashMap主要的区别有:线程安全性,同步(synchronization),以及速度。接下来通过本文给大家简单介绍下HashTable和HashMap的区别,需要的的朋友参考下吧
    2017-04-04
  • log4j如何根据变量动态生成文件名

    log4j如何根据变量动态生成文件名

    这篇文章主要介绍了log4j如何根据变量动态生成文件名方式,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-12-12
  • Java继承与多态的正确打开方式

    Java继承与多态的正确打开方式

    这篇文章主要为大家介绍了Java的继承与多态,具有一定的参考价值,感兴趣的小伙伴们可以参考一下,希望能够给你带来帮助
    2022-01-01
  • Java中使用Lambda表达式和函数编程示例

    Java中使用Lambda表达式和函数编程示例

    这篇文章介绍了Java中使用Lambda表达式和函数编程示例,该文章会演示多个示列,分别是变量声明上下文中的lambda、return语句上下文中的lambda、赋值上下文中的lambda、lambda在数组初始值设定项上下文中的用法等等,需要的朋友可以参考一下
    2021-10-10
  • Java毕业设计实战之共享租车信息管理系统的实现

    Java毕业设计实战之共享租车信息管理系统的实现

    这是一个使用了java+Jsp+Servlet+Jdbc+Mysql开发的共享租车信息管理系统,是一个毕业设计的实战练习,具有租车管理该有的所有功能,感兴趣的朋友快来看看吧
    2022-02-02
  • 解决SpringBoot在IDEA中热部署失效问题

    解决SpringBoot在IDEA中热部署失效问题

    热部署是指程序运行过程中实时更新或替换其组件的技术,即项目正在启动中,修改了配置文件中某个值或者添加了某个方法或者修改了某个方法参数,本文给大家介绍了解决SpringBoot在IDEA中热部署失效问题,需要的朋友可以参考下
    2024-01-01
  • 浅谈java 增强型的for循环 for each

    浅谈java 增强型的for循环 for each

    下面小编就为大家带来一篇浅谈java 增强型的for循环 for each。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2016-10-10

最新评论