spring-flux timeout源码分析

spring-flux timeout源码分析

• 正常和超时数据都会将数据放入ScheduledThreadPoolExecutor的队列中
• 正常结束的会从ScheduledThreadPoolExecutor队列中remove
• 超时数据会在ScheduledThreadPoolExecutor队列中积压等待定时器消费

mono flux timeout实现

public final Mono<T> timeout(Duration timeout) {
		return timeout(timeout, Schedulers.parallel());
}

Schedulers.parallel()

public static Scheduler parallel() {
		return cache(CACHED_PARALLEL, PARALLEL, PARALLEL_SUPPLIER);
	}

PARALLEL_SUPPLIER

static final Supplier<Scheduler> PARALLEL_SUPPLIER =
			() -> newParallel(PARALLEL, DEFAULT_POOL_SIZE, true);

newParallel实现

• ParallelScheduler类

ParallelScheduler(int n, ThreadFactory factory) {
        if (n <= 0) {
            throw new IllegalArgumentException("n > 0 required but it was " + n);
        }
        this.n = n;
        this.factory = factory;
        //初始化定时器（ScheduledThreadPoolExecutor），n默认无cpu核心数
        init(n);
    }

void init(int n) {
        ScheduledExecutorService[] a = new ScheduledExecutorService[n];
        for (int i = 0; i < n; i++) {
            a[i] = Schedulers.decorateExecutorService(Schedulers.PARALLEL, this);
        }
        EXECUTORS.lazySet(this, a);
    }
    //获取定时器ScheduledThreadPoolExecutor
    ScheduledExecutorService pick() {
        ScheduledExecutorService[] a = executors;
        if (a != SHUTDOWN) {
            // ignoring the race condition here, its already random who gets which executor
            int idx = roundRobin;
            if (idx == n) {
                idx = 0;
                roundRobin = 1;
            } else {
                roundRobin = idx + 1;
            }
            return a[idx];
        }
        return TERMINATED;
    }

timeout

public final Flux<T> timeout(Duration timeout,
			@Nullable Publisher<? extends T> fallback,
			Scheduler timer) {
		final Mono<Long> _timer = Mono.delay(timeout, timer).onErrorReturn(0L);
		final Function<T, Publisher<Long>> rest = o -> _timer;

		if(fallback == null) {
			return timeout(_timer, rest, timeout.toMillis() + "ms");
		}
		return timeout(_timer, rest, fallback);
	}
//生成FluxTimeout类
public final <U, V> Flux<T> timeout(Publisher<U> firstTimeout,
			Function<? super T, ? extends Publisher<V>> nextTimeoutFactory, Publisher<? extends T>
			fallback) {
		return onAssembly(new FluxTimeout<>(this, firstTimeout, nextTimeoutFactory,
				fallback));
	}

• FluxTimeout subscribe方法

public void subscribe(CoreSubscriber<? super T> actual) {
		CoreSubscriber<T> serial = Operators.serialize(actual);

		TimeoutMainSubscriber<T, V> main =
				new TimeoutMainSubscriber<>(serial, itemTimeout, other, timeoutDescription);

		serial.onSubscribe(main);

		TimeoutTimeoutSubscriber ts = new TimeoutTimeoutSubscriber(main, 0L);

		main.setTimeout(ts);
		//会执行ParallelScheduler类的directSchedule方法
		firstTimeout.subscribe(ts);

		source.subscribe(main);
	}
//exec定时器是通过pick方法获取
static Disposable directSchedule(ScheduledExecutorService exec,
			Runnable task,
			long delay,
			TimeUnit unit) {
		SchedulerTask sr = new SchedulerTask(task);
		Future<?> f;
		//0延时
		if (delay <= 0L) {
			f = exec.submit((Callable<?>) sr);
		}
		//delay时间定时执行
		else {
			//将任务放入队列，1个线程定时去消费队列
			f = exec.schedule((Callable<?>) sr, delay, unit);
		}
		sr.setFuture(f);
		return sr;
	}

• 正常结束
• 会调用ScheduledThreadPoolExecutor 的cancel方法从队列中移除任务，也可以debug查看调用栈

 public boolean cancel(boolean mayInterruptIfRunning) {
            boolean cancelled = super.cancel(mayInterruptIfRunning);
            if (cancelled && removeOnCancel && heapIndex >= 0)
                remove(this);
            return cancelled;
        }