code: public final FluxSink<IN> sink(FluxSink.OverflowStrategy strategy) {
  		Objects.requireNonNull(strategy, "strategy");
  		if (getBufferSize() == Integer.MAX_VALUE){
  			strategy = FluxSink.OverflowStrategy.IGNORE;
  		}
  
  		FluxCreate.BaseSink<IN> s = FluxCreate.createSink(this, strategy);
  		onSubscribe(s);
  
  		if(s.isCancelled() ||
  				(isSerialized() && getBufferSize() == Integer.MAX_VALUE)){
  			return s;
  		}
  		if (serializeAlways())
  			return new FluxCreate.SerializedSink<>(s);
  		else
  			return new FluxCreate.SerializeOnRequestSink<>(s);
  	}
docs: Create a {@link FluxSink} that safely gates multi-threaded producer
  {@link Subscriber#onNext(Object)}.  This processor will be subscribed to
  that {@link FluxSink}, and any previous subscribers will be unsubscribed.
  
  <p> The returned {@link FluxSink} will not apply any
  {@link FluxSink.OverflowStrategy} and overflowing {@link FluxSink#next(Object)}
  will behave in two possible ways depending on the Processor:
  <ul>
  <li> an unbounded processor will handle the overflow itself by dropping or
  buffering </li>
  <li> a bounded processor will block/spin on IGNORE strategy, or apply the
  strategy behavior</li>
  </ul>
  
  @param strategy the overflow strategy, see {@link FluxSink.OverflowStrategy}
  for the
  available strategies
  @return a serializing {@link FluxSink}