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);