注: 本文是由读者观看小马哥公开课视频过程中的笔记整理而成。
更多Spring Framework文章可参看笔者个人github: spring-framework-lesson 。
Spring 5实现了一部分Reactive
Spring WebFlux: Reactive Web(non-blocking servers in general)
Spring Web MVC:传统Servlet Web(servlet applications in general)
编程模型:阻塞、非阻塞
非阻塞
并发模型:
[线程:main] Observable 添加观察者! [线程:main] 通知所有观察者! [线程:main] 3. 收到数据更新:Hello World [线程:main] 2. 收到数据更新:Hello World [线程:main] 1. 收到数据更新:Hello World
[线程:main] 启动一个JFrame窗口! [线程:AWT-EventQueue-0] 销毁当前窗口! [线程:AWT-EventQueue-0] 窗口被关闭,退出程序!
使用Jconsole查看改异步非阻塞程序
等待总数一直在增加,说明异步程序一直在等待。NIO就是无限地在处理,无限地在等待。
Reactive Programming:响应式编程,异步非阻塞就是响应式编程(Reactive Programming),与之相对应的是命令式编程。
Reactive并不是一种新的技术,不用Reactive照样可以实现非阻塞(同步、异步均可,推拉模式的结合),比如利用观察者模式实现(比如Java Swing GUI技术)。
Reactive的另外一种实现方式就是消息队列。
https://en.wikipedia.org/wiki...
In computing , reactive programming is a declarative programming paradigm concerned with data streams and the propagation of change. With this paradigm it is possible to express static (e.g., arrays) or dynamic (e.g., event emitters) data streams with ease, and also communicate that an inferred dependency within the associated execution model exists, which facilitates the automatic propagation of the changed data flow
关键点:
Reactive标准: http://www.reactive-streams.org/
Reactive Streams JVM实现: https://github.com/reactive-s...
Handling streams of data—especially “live” data whose volume is not predetermined—requires special care in an asynchronous system. The most prominent issue is that resource consumption needs to be carefully controlled such that a fast data source does not overwhelm the stream destination. Asynchrony is needed in order to enable the parallel use of computing resources, on collaborating network hosts or multiple CPU cores within a single machine.
关键点:
In summary, Reactive Streams is a standard and specification for Stream-oriented libraries for the JVM that
ReactiveX: http://reactivex.io/intro.html
It extends the observer pattern to support sequences of data and/or events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety, concurrent data structures, and non-blocking I/O.
可观察的数据/事件序列(sequences of data and/or events)
You can think of the Observable class as a “push” equivalent to Iterable , which is a “pull.” With an Iterable, the consumer pulls values from the producer and the thread blocks until those values arrive.
Iterable是“pull”模式
https://projectreactor.io/doc...
CompletableFuture
, Stream
, and Duration
. It offers composable asynchronous sequence APIs Flux
(for [N] elements) and Mono
(for [0|1] elements), extensively implementing the Reactive Streams
specification.
Reactor also supports non-blocking inter-process communication with the reactor-netty
project. Suited for Microservices Architecture, Reactor Netty offers backpressure-ready network engines for HTTP (including Websockets), TCP, and UDP. Reactive Encoding and Decoding are fully supported.
https://docs.spring.io/spring...
The original web framework included in the Spring Framework, Spring Web MVC, was purpose-built for the Servlet API and Servlet containers. The reactive-stack web framework, Spring WebFlux, was added later in version 5.0. It is fully non-blocking, supports Reactive Streams back pressure, and runs on such servers as Netty, Undertow, and Servlet 3.1+ containers.
Filter
, Servlet
) or blocking ( getParameter
, getPart
). This was the motivation for a new common API to serve as a foundation across any non-blocking runtime. That is important because of servers (such as Netty) that are well-established in the async, non-blocking space.
The other part of the answer is functional programming. Much as the addition of annotations in Java 5 created opportunities (such as annotated REST controllers or unit tests), the addition of lambda expressions in Java 8 created opportunities for functional APIs in Java. This is a boon for non-blocking applications and continuation-style APIs (as popularized by CompletableFuture
and ReactiveX
) that allow declarative composition of asynchronous logic. At the programming-model level, Java 8 enabled Spring WebFlux to offer functional web endpoints alongside annotated controllers.
异步非阻塞
The term, “reactive,” refers to programming models that are built around reacting to change — network components reacting to I/O events, UI controllers reacting to mouse events, and others. In that sense, non-blocking is reactive, because, instead of being blocked, we are now in the mode of reacting to notifications as operations complete or data becomes available.
There is also another important mechanism that we on the Spring team associate with “reactive” and that is non-blocking back pressure. In synchronous, imperative code, blocking calls serve as a natural form of back pressure that forces the caller to wait. In non-blocking code, it becomes important to control the rate of events so that a fast producer does not overwhelm its destination.
Reactive Streams is a small spec (also adopted in Java 9) that defines the interaction between asynchronous components with back pressure. For example a data repository (acting as Publisher ) can produce data that an HTTP server (acting as Subscriber ) can then write to the response. The main purpose of Reactive Streams is to let the subscriber to control how quickly or how slowly the publisher produces data.
指的是围绕对变化作出反应而构建的编程模型
WebClient
to execute remote calls in parallel). On the whole, it requires more work to do things the non-blocking way and that can increase slightly the required processing time.
The key expected benefit of reactive and non-blocking is the ability to scale with a small, fixed number of threads and less memory. That makes applications more resilient under load, because they scale in a more predictable way. In order to observe those benefits, however, you need to have some latency (including a mix of slow and unpredictable network I/O). That is where the reactive stack begins to show its strengths, and the differences can be dramatic.
并不是为了变得更快
关键的一个好处(The key expected benefit)
防止回调地狱(Callback Hell)
Callbacks are hard to compose together, quickly leading to code that is difficult to read and maintain (known as "Callback Hell").
关于回调地域相关说明参见以下链接
回调地域
The second approach (mentioned earlier), seeking more efficiency, can be a solution to the resource wasting problem. By writing asynchronous , non-blocking code, you let the execution switch to another active task using the same underlying resources and later come back to the current process when the asynchronous processing has finished.
But how can you produce asynchronous code on the JVM? Java offers two models of asynchronous programming:
callback
parameter (a lambda or anonymous class) that gets called when the result is available. A well known example is Swing’s EventListener
hierarchy. Future<T>
immediately
. The asynchronous process computes a T
value, but the Future
object wraps access to it. The value is not immediately available, and the object can be polled until the value is available. For instance, ExecutorService
running Callable<T>
tasks use Future
objects. Long Live模式:Netty I/O连接(RPC)
Short Live模式:HTTP(需要超时时间)
短平快的应用并不适合Reactive,需要做合理的timeout时间规划
Reactive 性能测试: https://blog.ippon.tech/sprin...
Web:快速响应(Socket Connection Timeout)
Tomcat Connector Thread Pool(200个线程) --> Reactive Thread Pool(50个线程)
I/O连接从Tomcat转移到了Reactive
Reactive Thread负责处理任务(有可能会处理不过来)
利用Servlet 3.1规范中的异步处理(Asynchronous processing),异步上下文(AsyncContext)实现异步Servlet。
Some times a filter and/or servlet is unableto complete the processing of a request
without waiting for a resource or event before generating a response. For example, a
servlet may need to wait for an available JDBC connection, for a response from a
remote web service, for a JMS message, or for an application event, before
proceeding to generate a response. Waiting within the servlet is an inefficient
operation as it is a blocking operation that consumes a thread and other limited
resources. Frequently a slow resource such as a database may have many threads
blocked waiting for access and can cause thread starvation and poor quality of
service for an entire web container.
The asynchronous processing of requests is introduced to allow the thread may
return to the container and perform other tasks. When asynchronous processing
begins on the request, another thread or callback may either generate the response
and call completeor dispatch the request so that it may run in the context of the
container using the AsyncContext.dispatchmethod. A typical sequence of events
for asynchronous processing is:
利用Servlet 3.1规范中的Non Blocking IO
Non-blocking request processing in the Web Container helps improve the ever
increasing demand for improved Web Container scalability, increase the number of
connections that can simultaneously be handled by the Web Container. Nonblocking IO in the Servlet container allowsdevelopers to readdata as it becomes
available or write data when possible to do so. Non-blocking IO only works with
async request processing in Servlets and Filters (as defined in Section 2.3.3.3,
“Asynchronous processing” on page 2-10), and upgrade processing (as defined in
Section 2.3.3.5, “Upgrade Processing” on page 2-20). Otherwise, an
IllegalStateExceptionmust be thrown when
ServletInputStream.setReadListeneror
ServletOutputStream.setWriteListeneris invoked.
实现代码链接: github