RxJava2源码在探（下）：操作符和线程调度

    Observable.just(10086)

          return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
ublic final class ObservableJust<T> extends Observable<T>

    private final T value;
    public ObservableJust(final T value) {
        this.value = value;
        
            public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        
        new Function<Integer, Object>()
            .map(new Function<Integer, Object>() {
            public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
            
                
                Observable = this
             return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
                    public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
                      final Function<? super T, ? extends U> function;
                      
abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements 
HasUpstreamObservableSource<T> {
    protected final ObservableSource<T> source;
    
    
        public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        
        
            .subscribe(new Observer<Object>() {
            
                        subscribeActual(observer);

    
    public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    @Override
    public void subscribeActual(Observer<? super U> t) {
        source.subscribe(new MapObserver<T, U>(t, function));
    }
}

        MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
            super(actual);
            this.mapper = mapper;
        }
             actual.onNext(v);
             
        mapper.apply(t)

至此map操作符的源码分析完毕

三、线程调度
    线程调度分为subscribeOn和observeOn，这两个属于RxJava2功能性操作符中的线程调度操作符，对应事件订阅线程和接收线程。
    
    
    public final Observable<T> subscribeOn(Scheduler scheduler) {
    
        public static Scheduler io() {
        return RxJavaPlugins.onIoScheduler(IO);
    }
        public static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler) {
    
        static volatile Function<? super Scheduler, ? extends Scheduler> onIoHandler;
            Function<? super Scheduler, ? extends Scheduler> f = onIoHandler;
        if (f == null) {
            return defaultScheduler;
        }
        return apply(f, defaultScheduler);
        
         static <T, R> R apply(@NonNull Function<T, R> f, @NonNull T t) {
        try {
            return f.apply(t);
            
            
            Observable = this;
            return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
            
               public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }
    
    
    .subscribe(new Observer<Object>() {
    
      subscribeActual(observer);
            
               @Override
    public void subscribeActual(final Observer<? super T> observer) {
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);

        observer.onSubscribe(parent);

        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

 SubscribeOnObserver(Observer<? super T> downstream) {
            this.downstream = downstream;
            this.upstream = new AtomicReference<Disposable>();
        }
        
          SubscribeTask(SubscribeOnObserver<T> parent) {
            this.parent = parent;
        }

  @Override
        public void run() {
            source.subscribe(parent);
        }

        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
                    
                            final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
                            
                            
                          Function<? super Runnable, ? extends Runnable> f = onScheduleHandler;
        if (f == null) {
            return run;
        }
        return apply(f, run);

 @NonNull
    static <T, R> R apply(@NonNull Function<T, R> f, @NonNull T t) {
        try {
            return f.apply(t);
        } catch (Throwable ex) {
            throw ExceptionHelper.wrapOrThrow(ex);
        }
    }    
    R apply(@NonNull T t) throws Exception;    
    
       DisposeTask task = new DisposeTask(decoratedRun, w);
 
        w.schedule(task, delay, unit);