宜人贷蜂巢API网关技术解密之Netty使用实践

企业动态
本文先简要地介绍API网关的项目框架,其次对比BIO和NIO的特点,引入Netty作为项目的基础框架,然后介绍Netty线程池的原理,最后深入Netty线程池的初始化、ServerBootstrap的初始化与启动及channel与线程池的绑定过程,让读者了解Netty在承载高并发访问的设计路思。

宜人贷蜂巢团队,由Michael创立于2013年,通过使用互联网科技手段助力金融生态和谐健康发展。自成立起一直致力于多维度数据闭环平台建设。目前团队规模超过百人,涵盖征信、电商、金融、社交、五险一金和保险等用户授信数据的抓取解析业务,辅以先进的数据分析、挖掘和机器学习等技术对用户信用级别、欺诈风险进行预测评定,全面对外输出金融反欺诈、社交图谱、自动化模型定制等服务或产品。

目前宜人贷蜂巢基于用户授权数据实时抓取解析技术,并结合***大数据技术,快速迭代和自主的创新,已形成了强大而领先的聚合和输出能力。

为了适应完成宜人贷蜂巢强大的服务输出能力,蜂巢设计开发了自己的API网关系统,集中实现了鉴权、加解密、路由、限流等功能,使各业务抓取团队关注其核心抓取和分析工作,而API网关系统更专注于安全、流量、路由等问题,从而更好的保障蜂巢服务系统的质量。今天带着大家解密API网关的Netty线程池技术实践细节。

API网关作为宜人贷蜂巢数据开放平台的统一入口,所有的客户端及消费端通过统一的API来使用各类抓取服务。从面向对象设计的角度看,它与外观模式类似,包装各类不同的实现细节,对外表现出统一的调用形式。

本文首先,简要地介绍API网关的项目框架,其次对比BIO和NIO的特点,再引入Netty作为项目的基础框架,然后介绍Netty线程池的原理,***深入Netty线程池的初始化、ServerBootstrap的初始化与启动及channel与线程池的绑定过程,让读者了解Netty在承载高并发访问的设计思路。

一、项目框架

API网关项目框架

图1 - API网关项目框架

图中描绘了API网关系统的处理流程,以及与服务注册发现、日志分析、报警系统、各类爬虫的关系。其中API网关系统接收请求,对请求进行编解码、鉴权、限流、加解密,再基于Eureka服务注册发现模块,将请求发送到有效的服务节点上;网关及抓取系统的日志,会被收集到elk平台中,做业务分析及报警处理。

二、BIO vs NIO

API网关承载数倍于爬虫的流量,提升服务器的并发处理能力、缩短系统的响应时间,通信模型的选择是至关重要的,是选择BIO,还是NIO?

1. Streamvs Buffer & 阻塞 vs 非阻塞

BIO是面向流的,io的读写,每次只能处理一个或者多个bytes,如果数据没有读写完成,线程将一直等待于此,而不能暂时跳过io或者等待io读写完成异步通知,线程滞留在io读写上,不能充分利用机器有限的线程资源,造成server的吞吐量较低,见图2。而NIO与此不同,面向Buffer,线程不需要滞留在io读写上,采用操作系统的epoll模式,在io数据准备好了,才由线程来处理,见图3。

 BIO 从流中读取数据

图2 – BIO 从流中读取数据

图3 – NIO 从Buffer中读取数据

2. Selectors

NIO的selector使一个线程可以监控多个channel的读写,多个channel注册到一个selector上,这个selector可以监测到各个channel的数据准备情况,从而使用有限的线程资源处理更多的连接,见图4。所以可以这样说,NIO极大的提升了服务器接受并发请求的能力,而服务器性能还是要取决于业务处理时间和业务线程池模型。

NIO 单一线程管理多个连接

图4 – NIO 单一线程管理多个连接

而BIO采用的是request-per-thread模式,用一个线程负责接收TCP连接请求,并建立链路,然后将请求dispatch给负责业务逻辑处理的线程,见图5。一旦访问量过多,就会造成机器的线程资源紧张,造成请求延迟,甚至服务宕机。

图5 – BIO 一连接一线程

对比JDK NIO与诸多NIO框架后,鉴于Netty优雅的设计、易用的API、优越的性能、安全性支持、API网关使用Netty作为通信模型,实现了基础框架的搭建。

三、线程池

考虑到API网关的高并发访问需求,线程池设计,见图6。

图6 – API网关线程池设计

Netty的线程池理念有点像ForkJoinPool,不是一个线程大池子并发等待一条任务队列,而是每条线程都有一个任务队列。而且Netty的线程,并不只是简单的阻塞地拉取任务,而是在每个循环中做三件事情:

  • 先SelectKeys()处理NIO的事件
  • 然后获取本线程的定时任务,放到本线程的任务队列里
  • ***执行其他线程提交给本线程的任务

每个循环里处理NIO事件与其他任务的时间消耗比例,还能通过ioRatio变量来控制,默认是各占50%。可见,Netty的线程根本没有阻塞等待任务的清闲日子,所以也不使用有锁的BlockingQueue来做任务队列了,而是使用无锁的MpscLinkedQueue(Mpsc 是Multiple Producer, Single Consumer的缩写)。

四、NioEventLoopGroup初始化

下面分析下Netty线程池NioEventLoopGroup的设计与实现细节,NioEventLoopGroup的类层次关系见图7:

NioEvenrLoopGroup类层次关系

图7 –NioEvenrLoopGroup类层次关系

其创建过程——方法调用,见下图:

NioEvenrLoopGroup创建调用关系

图8 –NioEvenrLoopGroup创建调用关系

NioEvenrLoopGroup的创建,具体执行过程是执行类MultithreadEventExecutorGroup的构造方法:

  1. /**  
  2.  * Create a new instance.  
  3.  *  
  4.  * @param nThreads          the number of threads that will be used by this instance.  
  5.  * @param executor          the Executor to use, or {@code null} if the default should be used.  
  6.  * @param chooserFactory    the {@link EventExecutorChooserFactory} to use.  
  7.  * @param args              arguments which will passed to each {@link #newChild(Executor, Object...)} call  
  8.  */  
  9. protected MultithreadEventExecutorGroup(int nThreads, Executor executor,  
  10.                                         EventExecutorChooserFactory chooserFactory, Object... args) {  
  11.     if (nThreads <= 0) {  
  12.         throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));  
  13.     }  
  14.     if (executor == null) {  
  15.         executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());  
  16.     }  
  17.     children = new EventExecutor[nThreads];  
  18.     for (int i = 0; i < nThreads; i ++) {  
  19.         boolean success = false;  
  20.         try {  
  21.             children[i] = newChild(executor, args);  
  22.             success = true;  
  23.         } catch (Exception e) {   
  24.             throw new IllegalStateException("failed to create a child event loop", e);  
  25.         } finally {  
  26.             if (!success) {  
  27.                 for (int j = 0; j < i; j ++) {  
  28.                     children[j].shutdownGracefully();  
  29.                 }  
  30.                 for (int j = 0; j < i; j ++) { 
  31.                      EventExecutor e = children[j]; 
  32.                      try { 
  33.                          while (!e.isTerminated()) {  
  34.                             e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);  
  35.                         }  
  36.                     } catch (InterruptedException interrupted) {  
  37.                         // Let the caller handle the interruption.  
  38.                         Thread.currentThread().interrupt();  
  39.                         break;  
  40.                     }  
  41.                 }  
  42.             }  
  43.         }  
  44.     }  
  45.     chooser = chooserFactory.newChooser(children);  
  46.     final FutureListener<Object> terminationListener = new FutureListener<Object>() {  
  47.         @Override  
  48.         public void operationComplete(Future<Object> future) throws Exception {  
  49.             if (terminatedChildren.incrementAndGet() == children.length) {  
  50.                 terminationFuture.setSuccess(null);  
  51.             }  
  52.         }  
  53.     };  
  54.     for (EventExecutor e: children) {  
  55.         e.terminationFuture().addListener(terminationListener);  
  56.     }  
  57.     Set<EventExecutor> childrenSet = new LinkedHashSet<EventExecutor>(children.length);  
  58.     Collections.addAll(childrenSet, children);  
  59.     readonlyChildren = Collections.unmodifiableSet(childrenSet);  

其中,创建细节见下:

  • 线程池中的线程数nThreads必须大于0;
  • 如果executor为null,创建默认executor,executor用于创建线程(newChild方法使用executor对象);
  • 依次创建线程池中的每一个线程即NioEventLoop,如果其中有一个创建失败,将关闭之前创建的所有线程;
  • chooser为线程池选择器,用来选择下一个EventExecutor,可以理解为,用来选择一个线程来执行task。

chooser的创建细节,见下:

DefaultEventExecutorChooserFactory根据线程数创建具体的EventExecutorChooser,线程数如果等于2^n,可使用按位与替代取模运算,节省cpu的计算资源,见源码:

  1. @SuppressWarnings("unchecked")  
  2. @Override  
  3. public EventExecutorChooser newChooser(EventExecutor[] executors) {  
  4.     if (isPowerOfTwo(executors.length)) {  
  5.         return new PowerOfTowEventExecutorChooser(executors);  
  6.     } else {  
  7.         return new GenericEventExecutorChooser(executors);  
  8.     }  
  9. }   
  10.     private static final class PowerOfTowEventExecutorChooser implements EventExecutorChooser {  
  11.         private final AtomicInteger idx = new AtomicInteger();  
  12.         private final EventExecutor[] executors;   
  13.  
  14.         PowerOfTowEventExecutorChooser(EventExecutor[] executors) {  
  15.             this.executors = executors;  
  16.         }   
  17.  
  18.         @Override  
  19.         public EventExecutor next() {  
  20.             return executors[idx.getAndIncrement() & executors.length - 1];  
  21.         }  
  22.     }   
  23.  
  24.     private static final class GenericEventExecutorChooser implements EventExecutorChooser {  
  25.         private final AtomicInteger idx = new AtomicInteger();  
  26.         private final EventExecutor[] executors;   
  27.  
  28.         GenericEventExecutorChooser(EventExecutor[] executors) {  
  29.             this.executors = executors;  
  30.         }   
  31.  
  32.         @Override  
  33.         public EventExecutor next() {  
  34.             return executors[Math.abs(idx.getAndIncrement() % executors.length)];  
  35.         }  
  36.     } 

newChild(executor, args)的创建细节,见下:

MultithreadEventExecutorGroup的newChild方法是一个抽象方法,故使用NioEventLoopGroup的newChild方法,即调用NioEventLoop的构造函数:

  1. @Override  
  2.     protected EventLoop newChild(Executor executor, Object... args) throws Exception {  
  3.         return new NioEventLoop(this, executor, (SelectorProvider) args[0], 
  4.             ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2]);  
  5.     } 

在这里先看下NioEventLoop的类层次关系:

NioEventLoop的继承关系比较复杂,在AbstractScheduledEventExecutor 中,Netty 实现了 NioEventLoop 的 schedule 功能,即我们可以通过调用一个 NioEventLoop 实例的 schedule 方法来运行一些定时任务。而在 SingleThreadEventLoop 中,又实现了任务队列的功能,通过它,我们可以调用一个NioEventLoop 实例的 execute 方法来向任务队列中添加一个 task, 并由 NioEventLoop 进行调度执行。

通常来说,NioEventLoop 肩负着两种任务,***个是作为 IO 线程,执行与 Channel 相关的 IO 操作,包括调用 select 等待就绪的 IO 事件、读写数据与数据的处理等;而第二个任务是作为任务队列,执行 taskQueue 中的任务,例如用户调用 eventLoop.schedule 提交的定时任务也是这个线程执行的。

具体的构造过程,见下:

创建任务队列tailTasks(内部为有界的LinkedBlockingQueue):

创建线程的任务队列taskQueue(内部为有界的LinkedBlockingQueue),以及任务过多防止系统宕机的拒绝策略rejectedHandler。

其中tailTasks和taskQueue均是任务队列,而优先级不同,taskQueue的优先级高于tailTasks,定时任务的优先级高于taskQueue。

五、ServerBootstrap初始化及启动

了解了Netty线程池NioEvenrLoopGroup的创建过程后,下面看下API网关服务ServerBootstrap的是如何使用线程池引入服务中,为高并发访问服务的。

API网关ServerBootstrap初始化及启动代码,见下:

  1. serverBootstrap = new ServerBootstrap();  
  2. bossGroup = new NioEventLoopGroup(config.getBossGroupThreads());  
  3. workerGroup = new NioEventLoopGroup(config.getWorkerGroupThreads());   
  4.  
  5. serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)  
  6.         .option(ChannelOption.TCP_NODELAY, config.isTcpNoDelay())  
  7.         .option(ChannelOption.SO_BACKLOG, config.getBacklogSize())  
  8.         .option(ChannelOption.SO_KEEPALIVE, config.isSoKeepAlive())  
  9.         // Memory pooled  
  10.         .option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)  
  11.         .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)  
  12.         .childHandler(channelInitializer);    
  13.  
  14. ChannelFuture future = serverBootstrap.bind(config.getPort()).sync();  
  15. log.info("API-gateway started on port: {}", config.getPort());  
  16. future.channel().closeFuture().sync(); 

API网关系统使用netty自带的线程池,共有三组线程池,分别为bossGroup、workerGroup和executorGroup(使用在channelInitializer中,本文暂不作介绍)。其中,bossGroup用于接收客户端的TCP连接,workerGroup用于处理I/O、执行系统task和定时任务,executorGroup用于处理网关业务加解密、限流、路由,及将请求转发给后端的抓取服务等业务操作。

六、Channel与线程池的绑定

ServerBootstrap初始化后,通过调用bind(port)方法启动Server,bind的调用链如下:

  1. AbstractBootstrap.bind ->AbstractBootstrap.doBind -> AbstractBootstrap.initAndRegister 

其中,ChannelFuture regFuture = config().group().register(channel);中的group()方法返回bossGroup,而channel在serverBootstrap的初始化过程指定channel为NioServerSocketChannel.class,至此将NioServerSocketChannel与bossGroup绑定到一起,bossGroup负责客户端连接的建立。那么NioSocketChannel是如何与workerGroup绑定到一起的?

调用链AbstractBootstrap.initAndRegister -> AbstractBootstrap. init-> ServerBootstrap.init ->ServerBootstrapAcceptor.ServerBootstrapAcceptor ->ServerBootstrapAcceptor.channelRead:

  1. public void channelRead(ChannelHandlerContext ctx, Object msg) {  
  2.     final Channel child = (Channel) msg;  
  3.     child.pipeline().addLast(childHandler);  
  4.     for (Entry<ChannelOption<?>, Object> e: childOptions) {  
  5.         try {  
  6.             if (!child.config().setOption((ChannelOption<Object>) e.getKey(), e.getValue())) {  
  7.                 logger.warn("Unknown channel option: " + e);  
  8.             }  
  9.         } catch (Throwable t) {  
  10.             logger.warn("Failed to set a channel option: " + child, t); 
  11.         }  
  12.     }  
  13.     for (Entry<AttributeKey<?>, Object> e: childAttrs) {  
  14.         child.attr((AttributeKey<Object>) e.getKey()).set(e.getValue());  
  15.     } 
  16.  
  17.     try {  
  18.         childGroup.register(child).addListener(new ChannelFutureListener() {  
  19.             @Override  
  20.             public void operationComplete(ChannelFuture future) throws Exception {  
  21.                 if (!future.isSuccess()) { 
  22.                      forceClose(child, future.cause());  
  23.                 }  
  24.             }  
  25.         });  
  26.     } catch (Throwable t) {  
  27.         forceClose(child, t);  
  28.     }  

其中,childGroup.register(child)就是将NioSocketChannel与workderGroup绑定到一起,那又是什么触发了ServerBootstrapAcceptor的channelRead方法?

其实当一个 client 连接到 server 时,Java 底层的 NIO ServerSocketChannel 会有一个SelectionKey.OP_ACCEPT 就绪事件,接着就会调用到 NioServerSocketChannel.doReadMessages方法。

  1. @Override  
  2. protected int doReadMessages(List<Object> buf) throws Exception {  
  3.     SocketChannel ch = javaChannel().accept();  
  4.     try {  
  5.         if (ch != null) {  
  6.             buf.add(new NioSocketChannel(this, ch));  
  7.             return 1;  
  8.         }  
  9.     } catch (Throwable t) {          … 
  10.  
  11.     }  
  12.     return 0;  

javaChannel().accept() 会获取到客户端新连接的SocketChannel,实例化为一个 NioSocketChannel, 并且传入 NioServerSocketChannel 对象(即 this),由此可知, 我们创建的这个NioSocketChannel 的父 Channel 就是 NioServerSocketChannel 实例 。

接下来就经由 Netty 的 ChannelPipeline 机制,将读取事件逐级发送到各个 handler 中,于是就会触发前面我们提到的 ServerBootstrapAcceptor.channelRead 方法啦。

至此,分析了Netty线程池的初始化、ServerBootstrap的启动及channel与线程池的绑定过程,能够看出Netty中线程池的优雅设计,使用不同的线程池负责连接的建立、IO读写等,为API网关项目的高并发访问提供了技术基础。

七、总结

至此,对API网关技术的Netty实践分享就到这里,各位如果对中间的各个环节有什么疑问和建议,欢迎大家指正,我们一起讨论,共同学习提高。

参考:

  • http://tutorials.jenkov.com/java-nio/nio-vs-io.html
  • http://netty.io/wiki/user-guide-for-4.x.html
  • http://netty.io/
  • http://www.tuicool.com/articles/mUFnqeM
  • https://segmentfault.com/a/1190000007403873
  • https://segmentfault.com/a/1190000007283053

 【本文是51CTO专栏机构宜信技术学院的原创文章,微信公众号“宜信技术学院( id: CE_TECH)”】

戳这里,看该作者更多好文

责任编辑:赵宁宁 来源: 51CTO专栏
相关推荐

2019-04-18 22:40:42

蜂巢机器人金融机器人

2017-03-28 19:46:36

外设

2023-08-09 20:43:32

2017-06-19 11:05:44

互联网

2023-06-26 18:13:56

开源API

2022-08-22 08:40:42

API网关开发

2015-11-02 14:17:59

IoT蜂巢式

2017-03-13 14:09:19

RESTful API实践

2017-04-19 14:20:09

宜人贷

2023-06-26 10:51:56

开源API

2020-04-22 09:00:00

REST API参数化前端

2023-09-07 10:56:36

2017-04-25 10:57:16

宜人贷

2019-06-13 13:51:10

白山API大数据

2014-04-18 10:58:44

AndroidAPI实践

2020-07-07 07:54:01

API网关微服务

2021-11-24 08:55:38

代理网关Netty

2015-05-08 17:24:41

APIAPI网关Kong

2020-07-16 08:06:53

网关高性能

2014-08-05 15:10:05

Larbin搜索引擎
点赞
收藏

51CTO技术栈公众号