weixin_34228662
weixin_34228662

重学Android——Rxjava2.x源码解析

Rxjava的诞生背景

首先要从异步编程说起，最开始的原生的系统中，如果UI系统处理耗时任务，会引发ANR，所以都是放在子线程做耗时任务，比如网络请求或者IO操作，再来更新UI界面，这需要在主线程来完成，这样就涉及到了异步编程。

最开始的异步编程主要有：

  • 使用Java自身提供的Future模型
    • 但这种异步结果获取比较困难，必须调用Future.get()，回去查看异步是否完成，如果完成，就返回结果，否则继续等待。当然在JDK8后，提供了completabelFuture，简化了异步编程
  • Android系统提供的异步模型——AsyncTask。相比于Java提供的方法，此模型无主线程阻塞风险，但是最大的问题是有可能陷入层层嵌套的回调。

Rxjava源码中链式调用

多说也无益，先看源码。

分析问题时，我们可以从特殊到普通来分析，有时候会有意想不到的效果，所以这次源码由Single开始分析，我们最简单的用法：

先在app的gradle中

    implementation "io.reactivex.rxjava2:rxjava:2.2.9"
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
复制代码

最简单的实现

        Single.just(1)
                .subscribe(new SingleObserver() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onSuccess(Integer integer) {

            }

            @Override
            public void onError(Throwable e) {

            }
        });
    }
复制代码

这是最简单的用法，上游发送一个1的事件，下游接到，不牵涉线程切换。

创建被观察者

我们先直接进Just的源码

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    @NonNull
    public static  Single just(final T item) {
        //判空
        ObjectHelper.requireNonNull(item, "item is null");
        //HOOK方法
        return RxJavaPlugins.onAssembly(new SingleJust(item));
    }
复制代码

第一行，其实看方法名我们也能看出来，是判空的，源码如下

    public static  T requireNonNull(T object, String message) {
        if (object == null) {
            throw new NullPointerException(message);
        }
        return object;
    }
复制代码

果然不出所料，忽略

第二行，先看外层的RxJavaPlugins.onAssembly，进它的源码

    /**
     * Calls the associated hook function.
     * @param  the value type
     * @param source the hook's input value
     * @return the value returned by the hook
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @NonNull
    public static  Single onAssembly(@NonNull Single source) {
        Functionsuper Single, ? extends Single> f = onSingleAssembly;
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }
复制代码

注意看注释，说明了这是一个hook方法，可以看到直接return的说是传入进来的source，所以，我们可以得出，Single.just(item)就相当于new SingleJust(item)。

订阅过程

再来看.subscribe(new SingleObserver)的源码

   @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(SingleObserversuper T> observer) {
        //判空
        ObjectHelper.requireNonNull(observer, "observer is null");

        //HOOK
        observer = RxJavaPlugins.onSubscribe(this, observer);

        //继续判空
        ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null SingleObserver. Please check the handler provided to RxJavaPlugins.setOnSingleSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

        try {
            //执行当前类的subscribeActual
            subscribeActual(observer);
        } catch (NullPointerException ex) {
            throw ex;
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            NullPointerException npe = new NullPointerException("subscribeActual failed");
            npe.initCause(ex);
            throw npe;
        }
    }
复制代码

代码里有做注释，其实真正调用的方法是subscribeActual(observer);方法

protected abstract void subscribeActual(@NonNull SingleObserversuper T> observer);
复制代码

可以发现，这是一个抽象方法，那么我们要找到它的实现。

我们回到来看上面的方法其实可以发现，Single.just()调用的subscribe，而Single.just我们在上面讲到，就相当于new SingleJust()，所以我们只要看SingleJust里的subscribeActual方法就可以了。

public final class SingleJust<T> extends Single<T> {

    final T value;

    public SingleJust(T value) {
        this.value = value;
    }

    @Override
    protected void subscribeActual(SingleObserversuper T> observer) {
        observer.onSubscribe(Disposables.disposed());
        observer.onSuccess(value);
    }

}
复制代码

这个类超级简单，就是把上游的事件发送到下游SingleObserver，比如我们在实例中，Single.just(1)就相当于new SingleJust(1)，所以在这儿，value=1，然后调用subscribeActual方法，SingleObserver是一个接口，有三个方法，也是我们回调里的三个方法

public interface SingleObserver<T> {
    void onSubscribe(@NonNull Disposable d);

    void onSuccess(@NonNull T t);

    void onError(@NonNull Throwable e);
}
复制代码

在subscribeActual方法中，先observer.onSubscribe(Disposables.disposed());，需要注意的是，这也是just方法独有的，它直接在onSubscribe方法里就Disposables.disposed了，这个方法在后面讲，这是取消了事件订阅，因为它只会发一次，到了这就意味着已经不用订阅了。然后再调用observer.onSuccess方法，直接把value传递了过去。

Map操作符的源码

再来看增加一个操作符的源码，就用最常用的map，其实操作符一通百通

		Single.just(1)
                .map(new Function() {
                    @Override
                    public Integer apply(Integer integer) throws Exception {
                        return integer+2;
                    }
                })
                .subscribe(...);
复制代码

直接看map的源码

    public final  Single map(Functionsuper T, ? extends R> mapper) {
        //判空
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        //hook，就相当于new SingleMap
        return RxJavaPlugins.onAssembly(new SingleMap(this, mapper));
    }
复制代码

可以看到，这就相当于new SingleMap(this,mapper)；返回值依然是Single

我们看SingleMap的源码

public final class SingleMap<T, R> extends Single<R> {
    final SingleSource source;

    final Functionsuper T, ? extends R> mapper;

    public SingleMap(SingleSource source, Functionsuper T, ? extends R> mapper) {
        //这就是刚刚传进来的this，也就是上游的被观察者
        this.source = source;
        //这是我们自己在map中写的new function方法
        this.mapper = mapper;
    }

    //由上文subscribe方法分析可知，当调用subscribe时，这个回调是会被调用的
    @Override
    protected void subscribeActual(final SingleObserversuper R> t) {
        //可以看到，就是相当于是把上游的被观察者source，直接调用了它的subscribe方法
        //我们主要的精力只要集中看new MapSingleObserver方法就行
        source.subscribe(new MapSingleObserver(t, mapper));
    }

    //此observer观察者中，把处理后的数据都传递给了下游，但是，只提供了事件的流向，因为事件是在上游产生的
    static final class MapSingleObserver<T, R> implements SingleObserver<T> {

        final SingleObserversuper R> t;

        final Functionsuper T, ? extends R> mapper;

        MapSingleObserver(SingleObserversuper R> t, Functionsuper T, ? extends R> mapper) {
            this.t = t;
            this.mapper = mapper;
        }

        @Override
        public void onSubscribe(Disposable d) {
            t.onSubscribe(d);
        }

        @Override
        public void onSuccess(T value) {
            R v;
            try {
                //外面是判空，相当于就是mapper.apply(value)，这个方法其实就是我们自己的map方法
                v = ObjectHelper.requireNonNull(mapper.apply(value), "The mapper function returned a null value.");
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                onError(e);
                return;
            }
			//将map方法处理后的事件，传递给下游
            t.onSuccess(v);
        }

        @Override
        public void onError(Throwable e) {
            t.onError(e);
        }
    }
}
复制代码

看到这儿我们可以发现，事件流向是上游的被观察者流向观察者，在操作符中，因为操作符自身是继承了被观察者（在此处为Single），而在其自身中，有一个内部类是观察者（在此处为实现了SingleObserver的MapSingleObserver），事件由上游的被观察者，流向下游的观察者，而所有的操作符的结构都是一样的，每个操作符都只需要给上游操作符提供Observer，并给下游提供一个Observable，内部结构就是，从上游流向下游内部的observer被观察者，然后此下游的观察者observable会调用它自己下游的内部observer，这样，整条链就能运行了。

由此可知，Rxjava中，每个操作符内部都实现了一整套PUSH模型的接口体系。

由特殊到普通

现在回到最普通的Rxjava写法

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1);
                emitter.onComplete();
            }
        }).map(new Function() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                return integer+1;
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
            }

            @Override
            public void onNext(Integer integer) {
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onComplete() {
            }
        });
复制代码

先看create方法的源码

    public static  Observable create(ObservableOnSubscribe source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate(source));
    }
复制代码

通过上面的分析，我们一眼可以看出，就相当于new ObservableCreate(source)

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe source;

    public ObservableCreate(ObservableOnSubscribe source) {
        this.source = source;
    }

    @Override
    protected void subscribeActual(Observersuper T> observer) {
        CreateEmitter parent = new CreateEmitter(observer);//1
        observer.onSubscribe(parent);//2

        try {
            source.subscribe(parent);//3
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
	static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {
        ...
    }
    ...
}
复制代码

这个类比较长，我们先只看我们关心的部分。只以看到我们喜爱的subscribeActual方法，在订阅时，会调用到此方法。

再来逐句分析，在运行1语句时，new CreateEmitter，看到CreateEmitter的源码

	//实现了ObservableEmitter，ObservableEmitter是Emitter的子类，用于发射上游数据
	static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {

        private static final long serialVersionUID = -3434801548987643227L;

        final Observersuper T> observer;

		//下游的observer
        CreateEmitter(Observersuper T> observer) {
            this.observer = observer;
        }

        @Override
        public void onNext(T t) {
            if (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            if (!isDisposed()) {
            	//把事件传递给下游observer，调用观察者的onNext方法
                observer.onNext(t);
            }
        }
		...
    }
复制代码

再回到ObservableCreate的源码，它是被观察者Observable的子类，

  1. 先在1时new了一个发射器CreateEmitter对象，然后我们把自定义的下游观察者observer作为参数传了进去，这里同样也是包装起来，这个CreateEmitter实现了ObservableEmitter和Disposable接口
  2. 在2语句时，触发我们自定义的observer的onSubscribe(Disposable)方法，实际就是调用观察者的onSubscribe方法，告诉观察者已经成功订阅到被观察者了；
  3. 再执行在语句3，source.subscribe(parent);就和我们分析Map一样了，就是订阅，把事件从上游传到下游。
小结

Observable（被观察者）和Observer（观察者）建立连接，也就是订阅之后，会创建出一个发射器CreateEmitter，发射器会把被观察者中产生的事件发送到观察者中，观察者对发射器中发出的事件做出响应事件。可以看到，订阅成功之后，Observabel才会开始发送事件

切断消息源码分析

现在我们再来看dispose的实现。Disposabel是一个接口，可以理解Disposable是一个连接器，调用dispose后，这个连接就会中断。其具体实现在CreateEmitter类。我们现在主要来分析一下它的这一块源码。

在CreateEmitter中的dispose()方法

        @Override
        public void dispose() {
            DisposableHelper.dispose(this);
        }
复制代码

就是调用的DisposableHelper的dispose方法

public enum DisposableHelper implements Disposable {
    /**
     * The singleton instance representing a terminal, disposed state, don't leak it.
     */
    DISPOSED
    ;
	...
        
    public static boolean isDisposed(Disposable d) {
        //判断Disposable类型的变量的引用是否为DISPOSED
        //就可以判断这个连接器是否中断
        return d == DISPOSED;
    }
    
    public static boolean dispose(AtomicReference field) {
        Disposable current = field.get();
        Disposable d = DISPOSED;
        if (current != d) {
            //把field设置为DISPOSED
            current = field.getAndSet(d);
            if (current != d) {
                if (current != null) {
                    current.dispose();
                }
                return true;
            }
        }
        return false;
    }
    ...
}
复制代码

可以看到DisposableHelper是个枚举类，并且只有一个值DISPOSED。dispose方法就是把一个原子引用的field设为DISPOSED，这就是中断状态。而isDisposed()就是根据这个标志来判断是否中断的。

再回过头来看CreateEmiiter类的onNext这些方法

        @Override
        public void onNext(T t) {
            //省略无关代码

            if (!isDisposed()) {
                //如果没有dispose()，才会调用onNext()
                observer.onNext(t);
            }
        }

        @Override
        public void onError(Throwable t) {
            if (!tryOnError(t)) {
                //如果dispose()了，会调用到这里，即最终会崩溃
                RxJavaPlugins.onError(t);
            }
        }

        @Override
        public boolean tryOnError(Throwable t) {
            //省略无关代码
            if (!isDisposed()) {
                try {
                    //如果没有dispose()，才会调用onError()
                    observer.onError(t);
                } finally {
                    //onError()之后会dispose()
                    dispose();
                }
                //如果没有dispose()，返回true
                return true;
            }
            //如果dispose()了，返回false
            return false;
        }

        @Override
        public void onComplete() {
            if (!isDisposed()) {
                try {
                    //如果没有dispose()，才会调用onComplete()
                    observer.onComplete();
                } finally {
                    //onComplete()之后会dispose()
                    dispose();
                }
            }
        }
复制代码

很容易得出，

  • 如果没有dispose，observer的onNext才会被调用
  • onError与onComplete方法互斥，只能其中一个调用到，因为调用其中一个，就会把连接切断，dispose
  • 先onError后onComplete中是onComplete不会被调用，反过来的话，就会崩溃，因为onError中抛出了异常，实际上，dispose了后调用onError都会崩

再看一下操作符Map

    public final  Observable map(Functionsuper T, ? extends R> mapper) {
        ObjectHelper.requireNonNull(mapper, "mapper is null");
        return RxJavaPlugins.onAssembly(new ObservableMap(this, mapper));
    }

public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Functionsuper T, ? extends U> function;

    public ObservableMap(ObservableSource source, Functionsuper T, ? extends U> function) {
        super(source);
        this.function = function;
    }

    @Override
    public void subscribeActual(Observersuper U> t) {
        source.subscribe(new MapObserver(t, function));
    }

    static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
        final Functionsuper T, ? extends U> mapper;

        MapObserver(Observersuper U> actual, Functionsuper T, ? extends U> mapper) {
            super(actual);
            this.mapper = mapper;
        }

        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != NONE) {
                downstream.onNext(null);
                return;
            }

            U v;

            try {
                v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
            } catch (Throwable ex) {
                fail(ex);
                return;
            }
            downstream.onNext(v);
        }

        ...
    }
}
复制代码

可以看到，操作符其实和上面分析的特殊情况下的一样的，这里就省略分析了。

Rxjava线程切换

我们一般是这么使用的

        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext(1);
                emitter.onComplete();
            }
        }).map(new Function() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                return integer+1;
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer() {
            ...
        });
复制代码

通过subscribeOn来切换上游线程，observeOn来切换下游线程。

那么在源码中，是怎么的呢？

subscribeOn源码分析

Schedulers.io()

subscribeOn类型有好几种，这里就随便选择了Schedulers.io()来分析，别的其实都差不多的，分析了一个就行了。

    @NonNull
    public static Scheduler io() {
        //又是hook，就相当于IO
        return RxJavaPlugins.onIoScheduler(IO);
    }

public final class Schedulers {
    ...
    @NonNull
    static final Scheduler IO;
	
    ...

    static final class IoHolder {
        static final Scheduler DEFAULT = new IoScheduler();
    }


    static {
        //又是hook，就相当于new IOTask
        IO = RxJavaPlugins.initIoScheduler(new IOTask());
		...
    }
    
   	...
    static final class IOTask implements Callable<Scheduler> {
        @Override
        public Scheduler call() throws Exception {
            return IoHolder.DEFAULT;
        }
    }
}
复制代码

可以看到，最后这里就相当于new IoScheduler，先不看它的具体实现。

subscribeOn

我们继续看subscribeOn的源码

    public final Observable subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
    }
复制代码

可以看到和前面一样，就相当于返回new ObservableSubscribeOn

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }

    @Override
    public void subscribeActual(final Observersuper T> observer) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(observer);

        observer.onSubscribe(parent);

        //外层的parent.setDisposable是为了创建连接器，以便以后切断等控制的，可以只看里面
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }
    ...
}
复制代码

它的构造就是把source和scheduler两个都保存一下，在后面要用到的。

接下来我们来看订阅过程，虽然这里是线程切换，但是其实它也只是个操作符，和我们前面分析的是一样的，订阅过程和上面也是一样的，所以我们可以知道，当订阅发生后，ObservableSubscribeOn的subscribeActual方法就会被调用。

同样的，subscribeActual方法中，它把我们自定义的下游观察者observer包装成了SubscribeOnObserver对象，然后调用observer的onSubscribe方法，可以看到，目前为止，还没有发生任何的线程相关的东西，所以observer的onSubscribe()方法是运行在当前线程中的，那我们重点来看一下parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));方法。

我们先来看一下SubscribeTask类

	//是ObservableSubscribeOn的内部类，实现runnable接口，看到这，我们嗅到了线程的味道
	final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent;

        SubscribeTask(SubscribeOnObserver parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
            //这是的source就是我们自定义的Observable对象，就是ObservableCreate
            source.subscribe(parent);
        }
    }
复制代码

可以看到，这个类非常简单，实现了Runnable接口，在run方法中调用source.subscribe(parent);，这是个链式调用，会一层一层调用上去。

再来看scheduler.scheduleDirect

这是线程切换的核心部分了，一定要仔细看

    public Disposable scheduleDirect(@NonNull Runnable run) {
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }

	//run就是SubscribeTask
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        //createWorker在Schedule类中是个抽象方法，所以实现是在子类中
        //所以这个方法就是在IOSchedule中实现的
        //worker中可以执行runnabale
        final Worker w = createWorker();

        //实际上decoratedRun还是个run对象，也就是SubscribeTask
        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        //runnable和worker包装成一个DisposeTask
        DisposeTask task = new DisposeTask(decoratedRun, w);

        //Worker执行这个Task
        w.schedule(task, delay, unit);

        return task;
    }
复制代码

上面的代码注释已经写得非常详细了，scheduleDirect方法就是，new一个worker，然后使用这个worker来执行task线程。

再看一下IoIoScheduler中，createWorker以及shedule的过程

    public Worker createWorker() {
        //new一个EventLoopWorker并传一个worker的缓存池进去
        return new EventLoopWorker(pool.get());
    }

    static final class EventLoopWorker extends Scheduler.Worker {
        private final CompositeDisposable tasks;
        private final CachedWorkerPool pool;
        private final ThreadWorker threadWorker;

        final AtomicBoolean once = new AtomicBoolean();

        EventLoopWorker(CachedWorkerPool pool) {
            this.pool = pool;
            this.tasks = new CompositeDisposable();
            //从缓存worker池中取一个worker出来
            this.threadWorker = pool.get();
        }

        ...
            
        @NonNull
        @Override
        public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
            if (tasks.isDisposed()) {
                // don't schedule, we are unsubscribed
                return EmptyDisposable.INSTANCE;
            }
			
            //Runnable交给threadWorker去执行
            return threadWorker.scheduleActual(action, delayTime, unit, tasks);
        }
    }
复制代码

注意的是，不同的Scheduler类会有不同的Worker实现，因为Scheduler类最终都是交由worker来执行调度的，不过分析起来差别不大。

接下来我们看worker的缓存池操作

    static final class CachedWorkerPool implements Runnable {
        ...

        ThreadWorker get() {
            if (allWorkers.isDisposed()) {
                return SHUTDOWN_THREAD_WORKER;
            }
            while (!expiringWorkerQueue.isEmpty()) {
                //缓冲池不为空，就从缓存池中取一个threadWorker
                ThreadWorker threadWorker = expiringWorkerQueue.poll();
                if (threadWorker != null) {
                    return threadWorker;
                }
            }

            // No cached worker found, so create a new one.
            //为空就一个并返回去
            ThreadWorker w = new ThreadWorker(threadFactory);
            allWorkers.add(w);
            return w;
        }
		...
    }
复制代码

再看worker的执行代码threadWorker.scheduleActual

代码跟进，会发现实现在它的父类NewThreadWorker中

public class NewThreadWorker extends Scheduler.Worker implements Disposable {
	private final ScheduledExecutorService executor;

    volatile boolean disposed;

    public NewThreadWorker(ThreadFactory threadFactory) {
        //在构造中创建一个ScheduledExecutorService对象
        //可以通过它来使用线程池
        executor = SchedulerPoolFactory.create(threadFactory);
    }
	...
	public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        //这是decoratedRun就相当于run
        Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        //将decoratedRun包装成一个新对象ScheduledRunnable
        ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

        if (parent != null) {
            if (!parent.add(sr)) {
                return sr;
            }
        }

        Future f;
        try {
            if (delayTime <= 0) {
                //线程池中立即执行ScheduledRunnable
                f = executor.submit((Callable)sr);
            } else {
                //线程池中延迟执行ScheduledRunnable
                f = executor.schedule((Callable)sr, delayTime, unit);
            }
            sr.setFuture(f);
        } catch (RejectedExecutionException ex) {
            ...
        }

        return sr;
    }
 	...   
}
复制代码 
   
这里的executor就是使用线程池来执行任务，最终subscribeTask的run方法会在线程池中被执行，即上游的Observable的subscribe方法会在IO线程中调用了。
 
   
小结
 
   
     
    
  • Observer的onSubscribe方法运行在当前线程中，因为源码中并没有线程切换
    •  
    
  • 如果设置了subscribeOn(指定线程)，那么Observable中的subscribe方法将会运行在指定线程中。
    •  
    
  • 当多个subscribeOn调用时，因为从源码可知，线程的切换是从下往上的，最后也就是链式调用的第一个切换过程，才是有效的切换
    •  
   
 
   
observeOn源码分析
 
   
.observeOn(AndroidSchedulers.mainThread())
 
   
AndroidSchedulers.mainThread()
 
   
同样的，我们先看AndroidSchedulers.mainThread()的源码
 
   
    public static Scheduler mainThread() {
        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
    }
    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
            new Callable() {
                @Override public Scheduler call() throws Exception {
                    return MainHolder.DEFAULT;
                }
            });
    private static final class MainHolder {
        static final Scheduler DEFAULT
            = new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
    }
复制代码
 
   
这一段代码相信如果是看了上面的源码分析的话，一眼就能看出来，其实就相当于new HandlerScheduler(new Handler(Looper.getMainLooper()), false);，把一个主线程的Handler包装进了HandlerScheduler中。
 
   
observeOn
 
   
然后我们继续看observeOn的源码
 
   
    public final Observable observeOn(Scheduler scheduler) {
        return observeOn(scheduler, false, bufferSize());
    }
    public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize));
    }
复制代码
 
   
通过源码也可以知道，这里相当于直接new ObservableObserveOn
 
   
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;
    final boolean delayError;
    final int bufferSize;
    public ObservableObserveOn(ObservableSource source, Scheduler scheduler, boolean delayError, int bufferSize) {
        super(source);
        this.scheduler = scheduler;
        this.delayError = delayError;
        this.bufferSize = bufferSize;
    }

    @Override
    protected void subscribeActual(Observersuper T> observer) {
        //判断是否是当前线程
        if (scheduler instanceof TrampolineScheduler) {
            //是当前线程的话，直接调用下游的subscribe方法
            //也就是调用下一个Observable的subscibe方法
            source.subscribe(observer);
        } else {
            //创建worker
            //本例中的schedule为HandlerScheduler
            Scheduler.Worker w = scheduler.createWorker();

            //这里和上面分析有点类似，会将worker包装到ObserveOnObserver中
            //注意：source.subscribe没有涉及到worker，所以还是在之间设置的线程中执行
            source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
        }
    }
 	...   
}
复制代码
 
   
首先，判断是否已经在要切换的线程上了，如果是的话，那么直接调用。如果不是，那么使用HandlerScheduler包装一下worker，然后通过worker来把下游的事件进行切换，直接上游订阅，不做线程操作。
 
   
我们来看ObserveOnObserver类的源码
 
   
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>
    implements Observer<T>, Runnable {
		...

        ObserveOnObserver(Observersuper T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.downstream = actual;
            this.worker = worker;
            this.delayError = delayError;
            this.bufferSize = bufferSize;
        }

        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }

            if (sourceMode != QueueDisposable.ASYNC) {
            //将信息存入队列中
                queue.offer(t);
            }
            schedule();
        }
        ...

        void schedule() {
            if (getAndIncrement() == 0) {
            	//在这里调用
                worker.schedule(this);
            }
        }

        void drainNormal() {
            int missed = 1;

			//存储消息的队列
            final SimpleQueue q = queue;
            //这里的downstram实际就是下游的observer
            final Observersuper T> a = downstream;

            for (;;) {
                if (checkTerminated(done, q.isEmpty(), a)) {
                    return;
                }

                for (;;) {
                    boolean d = done;
                    T v;

                    try {
                    	//从队列中取出消息
                        v = q.poll();
                    } catch (Throwable ex) {
                        Exceptions.throwIfFatal(ex);
                        disposed = true;
                        upstream.dispose();
                        q.clear();
                        a.onError(ex);
                        worker.dispose();
                        return;
                    }
                    boolean empty = v == null;

                    if (checkTerminated(d, empty, a)) {
                        return;
                    }

                    if (empty) {
                        break;
                    }

					//调用下游的Observer的onNext
                    a.onNext(v);
                }

                missed = addAndGet(-missed);
                if (missed == 0) {
                    break;
                }
            }
        }

        @Override
        public void run() {
        	//outputFused默认是false
            if (outputFused) {
                drainFused();
            } else {
            //所以默认调用drainNormal
                drainNormal();
            }
        }
		...
    }
复制代码
 
   
由上面链式调用的分析可以知道，source.subscribe(observer)被调用时，会调用它
 
   
		CreateEmitter parent = new CreateEmitter(observer);
        observer.onSubscribe(parent);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
复制代码
 
   
可以知道，会通过发射器把上游的事件都发送到下游，然后订阅，所以ObserveOnObserver这个类中，onNext这个方法就会调用，然后执行schedule，最后执行worker.schedule(this);，因为传入的runnable是this，也就是最后线程后调用到本类的run方法，执行run，最终执行drainNormal()方法。
 
   
那我们再来看一下worker中是怎么create以及调用的。
 
   
在上面我们已经知道，这个schedule是HandlerSchedule
 
   
final class HandlerScheduler extends Scheduler {
    private final Handler handler;
    private final boolean async;

    HandlerScheduler(Handler handler, boolean async) {
        this.handler = handler;
        this.async = async;
    }

    ...

    @Override
    public Worker createWorker() {
       	//主线程的handler
        return new HandlerWorker(handler, async);
    }
}
复制代码
 
   
接着看HandlerWorker的schedule方法
 
   
    private static final class HandlerWorker extends Worker {
        private final Handler handler;
        private final boolean async;

        private volatile boolean disposed;

        HandlerWorker(Handler handler, boolean async) {
            this.handler = handler;
            this.async = async;
        }

        @Override
        @SuppressLint("NewApi") // Async will only be true when the API is available to call.
        public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
            if (run == null) throw new NullPointerException("run == null");
            if (unit == null) throw new NullPointerException("unit == null");

            if (disposed) {
                return Disposables.disposed();
            }

            run = RxJavaPlugins.onSchedule(run);

            //把Observer的runnable包装成ScheduledRunnable
            ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);

            //通过主线程Handler，把message Post到主线程去
            Message message = Message.obtain(handler, scheduled);
            message.obj = this; // Used as token for batch disposal of this worker's runnables.

            if (async) {
                message.setAsynchronous(true);
            }

            handler.sendMessageDelayed(message, unit.toMillis(delay));

            // Re-check disposed state for removing in case we were racing a call to dispose().
            if (disposed) {
                handler.removeCallbacks(scheduled);
                return Disposables.disposed();
            }

            return scheduled;
        }
        ...
    }
复制代码
 
   
可以看到，observeOn切换到主线程就是使用了主线程Handler来实现
 
   
小结
 
   
     
    
  • 如果设置了observerOn，那么Observer中的onNext等方法都会被切换到指定线程中
    •  
    
  • subscribeOn设置的线程不会影响到observerOn的
    •  
    
  • 如果设置了多个observerOn，因为它的切换线程是对下游起作用的，所以最后一个切换的才有效
    •  
   
 
   
扩展
 
   
Rxjava是基于PUSH模型构建的数据流，通过上游被观察者流向下游观察者，observer只负责消费，observable只负责复杂的数据逻辑，上下游没有沟通，不上游产生的数据远大于下游的处理能力的时候，会产生一系列问题，所以rxjava2.x除了Observable/observer核心类之外，还提供了一套flowable/subscribe核心类，它实现了背压功能，支持上下游速度协调，这一块等有时间再分析。
 
   
关于Rxjava的操作符的各种用法，可以参考RxJava2 只看这一篇文章就够了juejin.im/post/5b1756…
 
   
 
   
参考
 
   
RxJava的消息订阅和线程切换原理
 
   
 
   
我的CSDN
 
   
下面是我的公众号，欢迎大家关注我
 
   
 
   
 
   
  
转载于:https://juejin.im/post/5cffcb7b5188255e780b62d7
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,移动开发,ui)

        

            

                
    
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • swagger访问路径
                        igotyback
swagger
                        
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 你可能遗漏的一些C#/.NET/.NET Core知识点
                        追逐时光者
C#.NETDotNetGuide编程指南c#.net.netcoremicrosoft
                        
    前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • linux 发展史
                        种树的猴子
内核java操作系统linux大数据
                        
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • esp32开发快速入门 8 : MQTT 的快速入门，基于esp32实现MQTT通信
                        z755924843
ESP32开发快速入门服务器网络运维
                        
    MQTT介绍简介MQTT（MessageQueuingTelemetryTransport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • vue项目element-ui的table表格单元格合并
                        酋长哈哈
vue.jselementuijavascript前端
                        
    一、合并效果二全部代码exportdefault{name:'CellMerge',data(){return{tableData:[{id:'1',name:'王小虎',amount1:'165',amount2:'3.2',amount3:10},{id:'1',name:'王小虎',amount1:'162',amount2:'4.43',amount3:12},{id:'1',name:'
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • android 更改窗口的层次,浮窗开发之窗口层级
                        Ms.Bu
android更改窗口的层次
                        
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    
                    
    • 
                                
  • SAX解析xml文件
                                    小猪猪08
xml
                                    
    1.创建SAXParserFactory实例 
2.通过SAXParserFactory对象获取SAXParser实例 
3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 
4.SAXParser实例的parse来获取文件 
    public static void main(String[] args) { 
 //
    
                                
    • 
                                
  • 为什么mysql里的ibdata1文件不断的增长？
                                    brotherlamp
linuxlinux运维linux资料linux视频linux运维自学
                                    
    我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。 
当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。 
一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： 
ibdata1存了什么？ 
当你启用了 i
    
                                
    • 
                                
  • Quartz-quartz.properties配置
                                    eksliang
quartz
                                    
    其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。 
  
下面是这些默认值的解释 
#-----集群的配置
org.quartz.scheduler.instanceName =
    
                                
    • 
                                
  • informatica session的使用
                                    18289753290
workflowsessionlogInformatica
                                    
    如果希望workflow存储最近20次的log，在session里的Config  Object设置，log  options做配置，save  session log :sessions  run  ;savesessio log for  these runs:20 
session下面的source 里面有个tracing 
    
                                
    • 
                                
  • Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误
                                    酷的飞上天空
scrapy
                                    
    Scrapy版本0.14.4 
出现问题现象： 
  
ERROR: Error downloading <GET http://xxxxx  CRC check failed 
  
解决方法 
  
1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0' 
  
明确表示不支持任何形式的压缩格式，避免程序的解压
    
                                
    • 
                                
  • java Swing小集锦
                                    永夜-极光
java swing
                                    
    1.关闭窗体弹出确认对话框 
  1.1   this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE); 
  1.2   
	this.addWindowListener (
				new WindowAdapter () {
					public void windo
    
                                
    • 
                                
  • 强制删除.svn文件夹
                                    随便小屋
java
                                    
      
        在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
    
                                
    • 
                                
  • GET和POST有什么区别？及为什么网上的多数答案都是错的。
                                    aijuans
get post
                                    
      
    如果有人问你，GET和POST，有什么区别？你会如何回答？ 我的经历 
     前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。 
    这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
    
                                
    • 
                                
  • 谈谈新浪微博背后的那些算法
                                    aoyouzi
谈谈新浪微博背后的那些算法
                                    
    本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。 
微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
    
                                
    • 
                                
  • Connection reset 连接被重置的解决方法
                                    百合不是茶
java字符流连接被重置
                                    
    流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置 
  
被重置的代码如下; 
  
客户端代码; 
package 通信软件服务器;

import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.O
    
                                
    • 
                                
  • web.xml配置详解之filter
                                    bijian1013
javaweb.xmlfilter
                                    
    一.定义 
<filter>
	<filter-name>encodingfilter</filter-name>
	<filter-class>com.my.app.EncodingFilter</filter-class>
	<init-param>
		<param-name>encoding<
    
                                
    • 
                                
  • Heritrix
                                    Bill_chen
多线程xml算法制造配置管理
                                    
    作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 
Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
    
                                
    • 
                                
  • 【Zookeeper】FAQ
                                    bit1129
zookeeper
                                    
    1.脱离IDE，运行简单的Java客户端程序 
#ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient   
  
1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 
2. 如果Zookeeper集群跨越多个机房，那么Leader/
    
                                
    • 
                                
  • The user specified as a definer ('aaa'@'localhost') does not exist
                                    白糖_
localhost
                                    
    今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 
最后找原因发现删除操作做了触发器，而触发器里面有这样一句 
  
 /*!50017 DEFINER = ''aaa@'localhost' */ 
 原来最初
    
                                
    • 
                                
  • javascript中showModelDialog刷新父页面
                                    bozch
JavaScript刷新父页面showModalDialog
                                    
    在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行： 
      window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self 
      在子页面使用w
    
                                
    • 
                                
  • 编程之美-买书折扣
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;

public class BookDiscount {

	/**编程之美 买书折扣

书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。
下面用动态规划实现。
哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
    
                                
    • 
                                
  • 关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要
                                    chenbowen00
strutsWEB安全
                                    
    因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。 
下面记录下本次解决的过程以便后续 
1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议， 
而使用ftp协议默认会产生一个匿名用
    
                                
    • 
                                
  • [电力与暖气]煤炭燃烧与电力加温
                                    comsci

                                    
     
      在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区..... 
 
      不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢? 
 
  &nbs
    
                                
    • 
                                
  • oracle O7_DICTIONARY_ACCESSIBILITY参数
                                    daizj
oracle
                                    
    O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
    
                                
    • 
                                
  • 比较全面的MySQL优化参考
                                    dengkane
mysql
                                    
    本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。 
  
1、硬件层相关优化 
  
1.1、CPU相关 
  
在服务器的BIOS设置中，可
    
                                
    • 
                                
  • C语言homework2，有一个逆序打印数字的小算法
                                    dcj3sjt126com
c
                                    
    #h1# 
  
0、完成课堂例子 
1、将一个四位数逆序打印 
1234 ==> 4321 
实现方法一： 
# include <stdio.h>

int main(void)
{
	int i = 1234;
	int one = i%10;
	int two =  i / 10 % 10;
	int three = i / 100 % 10;

    
                                
    • 
                                
  • apacheBench对网站进行压力测试
                                    dcj3sjt126com
apachebench
                                    
       ab 的全称是 ApacheBench ， 是 Apache 附带的一个小工具 ， 专门用于 HTTP Server 的 benchmark testing ， 可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。 
通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。 
    
                                
    • 
                                
  • 2种办法让HashMap线程安全
                                    flyfoxs
javajdkjni
                                    
    多线程之--2种办法让HashMap线程安全 
多线程之--synchronized 和reentrantlock的优缺点 
多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync) 
  
  
HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全. 
  

    
                                
    • 
                                
  • Spring Security（04）——认证简介
                                    234390216
Spring Security认证过程
                                    
    认证简介 
目录 
1.1     认证过程 
1.2     Web应用的认证过程 
1.2.1    ExceptionTranslationFilter 
1.2.2    在request之间共享SecurityContext 
   

1
    
                                
    • 
                                
  • Java 位运算
                                    Javahuhui
java位运算
                                    
    // 左移( << ) 低位补0 
// 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： 
// 0000 0000 0000 0000 0000 0000 0001 1000 
System.out.println(6 << 2);// 运行结果是24 
 
// 右移( >> ) 高位补"
    
                                
    • 
                                
  • mysql免安装版配置
                                    ldzyz007
mysql
                                    
    1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 
2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 
3、my-large.ini是为专用于一个SQL数据
    
                                
    • 
                                
  • MFC和ado数据库使用时遇到的问题
                                    你不认识的休道人
sqlC++mfc
                                    
    =================================================================== 
第一个 
=================================================================== 
 
try{
		CString sql;
	sql.Format("select * from p
    
                                
    • 
                                
  • 表单重复提交Double Submits
                                    rensanning
double
                                    
    可能发生的场景： 
 
 
 *多次点击提交按钮  
 *刷新页面  
 *点击浏览器回退按钮  
 *直接访问收藏夹中的地址  
 *重复发送HTTP请求（Ajax） 
 
（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。 
这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： 
http://getbootstrap.co
    
                                
    • 
                                
  • Java String 十大常见问题
                                    tomcat_oracle
java正则表达式
                                    
    　1.字符串比较，使用“==”还是equals()?   　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。   　　equals()判断两个字符串的值是否相等。   　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。   　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。   　 
　
    
                                
    • 
                                
  • SpringMVC 登陆拦截器实现登陆控制
                                    xp9802
springMVC
                                    
    思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。 
  
实现方法： 
        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23  
    
                                
    •