想让系统更具有弹性？了解背压机制和响应式流的秘密！

public interface Publisher {
 
     /**
      * 请求 Publisher 开始流式传输数据。
 这是一个“工厂方法”，可以多次调用，每次开始一个新的 Subscription.
 每个 Subscription 只能为一个 Subscriber.
 A Subscriber 只能订阅一次 Publisher单个 .
 如果 拒绝 Publisher 订阅尝试或失败，它将通过 发出 Subscriber.onError(Throwable)错误信号。
 参数：
 sSubscriber– 将消耗来自此的信号Publisher
      * Request {@link Publisher} to start streaming data.
      * 

      * This is a "factory method" and can be called multiple times, each time starting a new {@link Subscription}.
      * 

      * Each {@link Subscription} will work for only a single {@link Subscriber}.
      * 

      * A {@link Subscriber} should only subscribe once to a single {@link Publisher}.
      * 

      * If the {@link Publisher} rejects the subscription attempt or otherwise fails it will
      * signal the error via {@link Subscriber#onError(Throwable)}.
      *
      * @param s the {@link Subscriber} that will consume signals from this {@link Publisher}
      */
     public void subscribe(Subscriber super T> s);
 }

public interface Subscriber {
 
     /**
      * Invoked after calling {@link Publisher#subscribe(Subscriber)}.
      * 

      * No data will start flowing until {@link Subscription#request(long)} is invoked.
      * 

      * It is the responsibility of this {@link Subscriber} instance to call {@link Subscription#request(long)} whenever more data is wanted.
      * 

      * The {@link Publisher} will send notifications only in response to {@link Subscription#request(long)}.
      * 
      * @param s the {@link Subscription} that allows requesting data via {@link Subscription#request(long)}
      */
     public void onSubscribe(Subscription s);
 
     /**
      * Data notification sent by the {@link Publisher} in response to requests to {@link Subscription#request(long)}.
      * 
      * @param t the element signaled
      */
     public void onNext(T t);
 
     /**
      * Failed terminal state.
      * 

      * No further events will be sent even if {@link Subscription#request(long)} is invoked again.
      *
      * @param t the throwable signaled
      */
     public void onError(Throwable t);
 
     /**
      * Successful terminal state.
      * 

      * No further events will be sent even if {@link Subscription#request(long)} is invoked again.
      */
     public void onComplete();
 }

public interface Subscription {
 
     /**
      * No events will be sent by a {@link Publisher} until demand is signaled via this method.
      * 

      *  It can be called however often and whenever needed—but if the outstanding cumulative demand ever becomes Long.MAX_VALUE or more,
      *  it may be treated by the {@link Publisher} as "effectively unbounded".
      * 

      * Whatever has been requested can be sent by the {@link Publisher} so only signal demand for what can be safely handled.
      * 

      * A {@link Publisher} can send less than is requested if the stream ends but
      * then must emit either {@link Subscriber#onError(Throwable)} or {@link Subscriber#onComplete()}.
      * 
      * @param n the strictly positive number of elements to requests to the upstream {@link Publisher}
      */
     public void request(long n);
 
     /**
      * Request the {@link Publisher} to stop sending data and clean up resources.
      * 

      * Data may still be sent to meet previously signalled demand after calling cancel.
      */
     public void cancel();
 }