WonderSky_HY
WonderSky_HY

RxJava2笔记（三、订阅线程切换）

在前面两篇文章RxJava2笔记（一、事件订阅流程）和RxJava2笔记（二、事件取消流程）中，我们分别了解了事件的订阅以及取消是如何进行的，接下来我们将要介绍RxJava的线程切换。

对RxJava有过了解的肯定知道，前面的代码都是运行在主线程当中，让我们来确认下，继续对代码做一些改动，添加些打印日志，打印各个方法的当前运行线程：

Observer observer = new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.i(TAG, "onSubscribe--运行线程：" + Thread.currentThread().getName());
        disposable = d;
    }

    @Override
    public void onNext(Integer integer) {
        Log.i(TAG, "onNext: " + integer + " --运行线程：" + Thread.currentThread().getName());
    }

    @Override
    public void onError(Throwable e) {
        Log.i(TAG, "onError: " + e.getMessage());
        e.printStackTrace();
    }

    @Override
    public void onComplete() {
        Log.i(TAG, "onComplete--运行线程：" + Thread.currentThread().getName());
    }
};

Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) {
        Log.i(TAG, "subscribe--运行线程：" + Thread.currentThread().getName());
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
}).subscribe(observer);

输出结果如下：

I/MainActivity: onSubscribe--运行线程：main
    subscribe--运行线程：main
I/MainActivity: onNext: 1 --运行线程：main
    onNext: 2 --运行线程：main
    onNext: 3 --运行线程：main
    onComplete--运行线程：main

可以看到，所有的线程都运行在主线程当中。

而在实际开发中，我们需要为网络请求相关代码单独开启一个子线程，将网络请求代码运行在这个子线程中，当网络请求结束返回数据并开始更新UI界面时，我们需要将线程切换回主线程后才能去更新UI界面，否则就会报错（android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views. at android.view.ViewRootImpl.checkThread(ViewRootImpl.java:6838)）
这段话的意思其实就是我们只可以在主线程中更新UI，当我们在其他线程中更新UI时，就会抛出这个异常。

而使用RxJava切换线程也非常简单，只需要添加两个调用方法即可：


RxJava2笔记（三、订阅线程切换）_第1张图片
image.png

我们在订阅线程添加了一行代码TimeUnit.MILLISECONDS.sleep(1000)来模拟网络请求。如果在此处不添加这行代码，当我们把observeOn(AndroidSchedulers.mainThread())这行代码去掉时，程序仍能正常运行，有兴趣的读者可以试一下。至于原因，参考这篇文章Android中子线程真的不能更新UI吗？。

好了，按照上图的代码，我们再打印下结果（打印结果中间乱入了两行，这是因为订阅线程睡眠了1s的缘故，我们直接无视掉就行）：

I/MainActivity: onSubscribe--运行线程：main
I/MainActivity: subscribe--运行线程：RxCachedThreadScheduler-1
I/MainActivity: onNext: 1 --运行线程：main
I/MainActivity: onNext: 2 --运行线程：main
I/OpenGLRenderer: Initialized EGL, version 1.4
W/art: Before Android 4.1, method int android.support.v7.widget.DropDownListView.lookForSelectablePosition(int, boolean) would have incorrectly overridden the package-private method in android.widget.ListView
I/MainActivity: onNext: 3 --运行线程：main
I/MainActivity: onComplete--运行线程：main

从上面的结果可以看到，我们的订阅线程（即发射数据事件所在的线程，也就是被观察者）运行在了名为RxCachedThreadScheduler-1这个线程中，而observer的四个方法（观察者）均运行在main线程中（也就是UI线程）。接下来我们就开始分析这两个线程切换代码做了哪些工作。

我们先从订阅线程开始：

将订阅线程切换到子线程运行

将订阅线程切换到子线程只需要调用方法subscribeOn(Schedulers.io())就能完成切换。那么这个方法做了哪些工作呢？我们点进去看看：

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.CUSTOM)
public final Observable subscribeOn(Scheduler scheduler) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
}

该方法接收一个Scheduler类型的参数，这个Scheduler类就是负责线程调度的，关于这个类我们稍后再讨论。沿着上面的代码接着分析下去，subscribeOn(Scheduler scheduler)方法将传入的scheduler参数又传递到了new ObservableSubscribeOn(this, scheduler)这个构造方法中，然后通过RxJavaPlugins.onAssembly将这个生成的ObservableSubscribeOn对象作为钩子返回生成一个新的Observable对象。我们接着来看ObservableSubscribeOn这个类：

public final class ObservableSubscribeOn extends AbstractObservableWithUpstream{
}

发现它继承了AbstractObservableWithUpstream这个类

/**
 * Base class for operators with a source consumable.
 *
 * @param  the input source type
 * @param  the output type
 */
abstract class AbstractObservableWithUpstream extends Observable implements HasUpstreamObservableSource {

    /** The source consumable Observable. */
    protected final ObservableSource source;

    /**
     * Constructs the ObservableSource with the given consumable.
     * @param source the consumable Observable
     */
    AbstractObservableWithUpstream(ObservableSource source) {
        this.source = source;
    }

    @Override
    public final ObservableSource source() {
        return source;
    }
}

通过源码可以发现，AbstractObservableWithUpstream继承了Observable，其内部有个ObservableSource类型成员变量source，这个ObservableSource又是什么？我们点进去看下

/**
 * Represents a basic, non-backpressured {@link Observable} source base interface,
 * consumable via an {@link Observer}.
 *
 * @param  the element type
 * @since 2.0
 */
public interface ObservableSource {

    /**
     * Subscribes the given Observer to this ObservableSource instance.
     * @param observer the Observer, not null
     * @throws NullPointerException if {@code observer} is null
     */
    void subscribe(@NonNull Observer observer);
}

可以看出，ObservableSource是一个接口，Observable实现了这个接口，而这个接口和前面的ObservableOnSubscribe接口如出一辙。因此AbstractObservableWithUpstream中的source成员变量就是用来保存上游传递下来的observable，也就是Observable.create方法生成的数据源。
我们来看下ObservableSubscribeOn的源码：

public final class ObservableSubscribeOn extends AbstractObservableWithUpstream {
    //1、线程调度器，这里是负责订阅线程切换
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
        //2、保存上游传递的observable
        super(source);
        this.scheduler = scheduler;
    }

    @Override
    public void subscribeActual(final Observer s) {
        //3、封装外部传递进来的观察者对象（将observer包装起来，这是一个装饰器模式）
        final SubscribeOnObserver parent = new SubscribeOnObserver(s);
        //4、建立订阅关系（观察者调用自己的onSubscribe方法）
        s.onSubscribe(parent);
        //5、将订阅线程中的disposable赋值给parent（也就是SubscribeOnObserver对象）
        //这里使用scheduler开始线程调度，将外部observer的包装对象parent用SubscribeTask构造方法包装起来并使这个SubscribeTask运行在我们指定的线程中
        //这个SubscribeTask是一个Runnable，实际上真正的订阅是发生在它的run()方法里面，而这个run()方法正是运行在我们前面指定的线程中（比如Schedulers.io()指定的IO线程）。
        //这样我们就完成了线程切换
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

    static final class SubscribeOnObserver extends AtomicReference implements Observer, Disposable {
    //......代码省略
    }

    final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent;

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

        @Override
        public void run() {
            //6、订阅事件发生
            source.subscribe(parent);
        }
    }
}

在步骤3中，这个外部observer的包装类SubscribeOnObserver跟前面所讲的CreateEmitter相比较起来，虽然它们都是observer包装类，但还是有一定的区别的，我们来分析下这个类：

static final class SubscribeOnObserver extends AtomicReference implements Observer, Disposable {
    private static final long serialVersionUID = 8094547886072529208L;
    //7、保存外部传进来的observer对象
    //（这里的actual用于保存下游传递过来的observer，
    //当前这个类SubscribeOnObserver对象可以看做是介于上游observable和下游observer之间的一个中间observer，主要用于辅助订阅线程切换）
    final Observer actual;
    //8、保存订阅发生时生成的disposable，用于后续的解除订阅
    final AtomicReference s;

    SubscribeOnObserver(Observer actual) {
        this.actual = actual;
        this.s = new AtomicReference();
    }
        
    @Override
    public void onSubscribe(Disposable s) {
        //9、该方法在调用source.subscribe(parent)时最先调用，
        //将当前订阅事件产生的disposable保存到AtomicReference s这个成员变量中，用于之后取消订阅
        //（从上面的代码可以看出这里传入的参数实际上就是SubscribeOnObserver自身对象）
        DisposableHelper.setOnce(this.s, s);
    }

    @Override
    public void onNext(T t) {
        //10、这里调用下游observer的onNext方法，actual保存的就是下游传递过来的observer
        //后面的onComplete和onError方法同理
        actual.onNext(t);
    }

    @Override
    public void onError(Throwable t) {
        actual.onError(t);
    }

    @Override
    public void onComplete() {
        actual.onComplete();
    }

    @Override
    public void dispose() {
        //11、取消订阅时除了要终止当前订阅事件（onSubscribe方法被调用时保存的disposable（保存在其成员变量s中）），
        //还要终止scheduler线程调度时保存其返回的task（保存在其自身），
        //因为网络请求任务是运行在独立的线程中，终止订阅事件时，我们也需要终止相应运行的线程
        DisposableHelper.dispose(s);
        DisposableHelper.dispose(this);
    }

    @Override
    public boolean isDisposed() {
        return DisposableHelper.isDisposed(get());
    }

    //12、这个方法是在ObservableSubscribeOn类中的subscribeActual方法内部调用的，
    //用于保存scheduler进行线程调度时返回的task（实际上返回的是DisposeTask类型的对象，它实现了Disposable接口，这个后面再讨论）
    //这里是将scheduler线程调度时返回的task保存到自身
    //（SubscribeOnObserver继承了AtomicReference类（继承该类保证了线程安全）和Disposable接口）
    void setDisposable(Disposable d) {
        DisposableHelper.setOnce(this, d);
    }
}

我们来梳理下思路：

  • 1、当我们调用subscribeOn(Schedulers.io())方法时，调用这个方法的对象实际上是Observable.create方法生成的一个新的observable对象（即ObservableCreate对象，该对象有个source成员变量，用于保存上游传递过来的observable被观察者，也就是事件源）；调用subscribeOn这个方法又会产生一个新的observable对象（通过new ObservableSubscribeOn(this, scheduler)得到），用于进一步的事件操作。
  • 2、步骤1中提到的ObservableSubscribeOn构造方法第一个参数是ObservableSource接口类型（Observable实现了这个接口）的参数，该参数实际上接收的是步骤1中的ObservableCreate对象，并保存在其成员变量source中（类型为ObservableSource，通过继承AbstractObservableWithUpstream得到）。
  • 3、在ObservableSubscribeOn类的subscribeActual(final Observer s)方法中（这个方法接收的observer参数是从下游传递过来的），将外部传进来的observer对象用SubscribeOnObserver内部类包装起来（保存在其成员变量actual中）得到该内部类的一个对象parent（通过SubscribeOnObserver parent = new SubscribeOnObserver(s)，这个内部类主要用于辅助订阅线程切换）。
  • 4、然后通过s.onSubscribe(parent)建立订阅关系，最后执行parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)))，通过scheduler.scheduleDirect(new SubscribeTask(parent))完成线程切换。（备注：SubscribeTask是一个Runnable，这里是将parent传入到SubscribeTask的构造方法中，并在SubscribeTask的run()方法中执行订阅（source.subscribe(parent)））。

至此，订阅线程的切换流程就介绍完了，本文也就告一段落。下面，还有几个细节，如果只关注订阅线程切换流程的话，可以结束本文的阅读了。

留下的几个问题：

调用subscribeOn(Schedulers.io())这个传入的Schedulers.io()到底是啥？

我们点进去看下代码：

/**
 * Returns a default, shared {@link Scheduler} instance intended for IO-bound work.
 * ......已省略
 * @return a {@link Scheduler} meant for IO-bound work
 */
@NonNull
public static Scheduler io() {
     return RxJavaPlugins.onIoScheduler(IO);
}

看注释，我们了解到这个方法是返回一个绑定在IO操作的默认共享实例，返回类型是Scheduler类型。RxJavaPlugins我们前面提到过，它的作用是返回一个钩子，这里返回的是一个常量IO，这个IO主要负责网络通信任务。其实Schedulers类内部声明了很多个常量，我们大致看下：

public final class Schedulers {
    @NonNull
    static final Scheduler SINGLE;

    @NonNull
    static final Scheduler COMPUTATION;

    @NonNull
    static final Scheduler IO;

    @NonNull
    static final Scheduler TRAMPOLINE;

    @NonNull
    static final Scheduler NEW_THREAD;

    static final class SingleHolder {
        static final Scheduler DEFAULT = new SingleScheduler();
    }

    static final class ComputationHolder {
        static final Scheduler DEFAULT = new ComputationScheduler();
    }

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

    static final class NewThreadHolder {
        static final Scheduler DEFAULT = new NewThreadScheduler();
    }

    static {
        SINGLE = RxJavaPlugins.initSingleScheduler(new SingleTask());

        COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());

        IO = RxJavaPlugins.initIoScheduler(new IOTask());

        TRAMPOLINE = TrampolineScheduler.instance();

        NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
    }
    //......代码省略
}

Schedulers类一共内置了5个Scheduler类型的常量，除了IO之外，其他几个也简单介绍下：

  • SINGLE：创建一个共享的单一线程，所有工作均在这个线程里面执行
  • COMPUTATION：创建一个指定数量线程的线程池，主要适用于计算密集型的任务
  • IO：创建一个预置一定数量线程的线程池，主要用于IO密集型的任务
  • TRAMPOLINE：使用该种方式的任务会在当前线程上运行，但并不会马上执行，任务会被保存在一个队列中，等当前任务执行完后再从队列中把该任务取出来并执行。
  • NEW_THREAD：直接启动一个新线程执行指定任务。
  • 还有一种创建线程的方式：Scheduler from(@NonNull Executor executor)，这是由我们自己指定线程创建以及调度方式。

上面六种方式常用的为IO和COMPUTATION，本文我们就分析下这个IO，COMPUTATION其实和IO是类似的，读者可以自行分析。
我们看到这个常量IO执行了静态代码初始化，初始化为一个IOTask对象：

static final class IOTask implements Callable {
    @Override
    public Scheduler call() throws Exception {
        return IoHolder.DEFAULT;
    }
}

Callable和Runnable类似，区别是使用Callable可以得到返回值，而使用Runnable则没有返回值。
上面的代码在call()方法内返回了IoHolder.DEFAULT，最终返回一个IoScheduler类型的对象：

IO = RxJavaPlugins.initIoScheduler(new IOTask());

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

有人在这里可能就有疑问，Schedulers.io()返回的是一个Scheduler对象啊，这个IOTask的call()方法是什么时候执行的呢？
我们可以看到，IO这个变量在声明的时候它的类型就是Scheduler类型，因此可以想到它在初始化的时候必然是经过了一些处理。我们看下IO的初始化代码：

IO = RxJavaPlugins.initIoScheduler(new IOTask());

这里直接将IOTask对象作为参数传递给 RxJavaPlugins.initIoScheduler(@NonNull Callable defaultScheduler)方法，这个方法正好接收一个Callable对象，看来call()方法应该就是在这里面执行的，点进去看下：

@NonNull
public static Scheduler initIoScheduler(@NonNull Callable defaultScheduler) {
    ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");
    Function, ? extends Scheduler> f = onInitIoHandler;
    if (f == null) {
        return callRequireNonNull(defaultScheduler);
    }
    return applyRequireNonNull(f, defaultScheduler);
}

我们看下这个方法，首先验证传入的参数不能为空，然后定义一个Function类型的临时变量f，并用同是类型为Function的成员变量onInitIoHandler为其赋值，然后判断f==null是否成立，也就是onInitIoHandler==null是否成立。这里f==null是成立的，原因是RxJavaPlugins内部并没有onInitIoHandler预初始化方法，只有与其相关的Getter和Setter方法，而在本文开始到目前为止，onInitIoHandler的Setter方法也并没有被调用过，因此onInitIoHandler为null，自然f==null也就为true，因此调用callRequireNonNull(defaultScheduler)方法，我们点进这个方法看下：

static Scheduler callRequireNonNull(@NonNull Callable s) {
    try {
        return ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't be null");
    } catch (Throwable ex) {
        throw ExceptionHelper.wrapOrThrow(ex);
    }
}

终于，我们看到了call()方法的调用。上面说到，在IOTask类中，call()方法返回的是一个IoScheduler对象，因此结合前面的分析，这个IO在静态初始化的时候就被初始化为一个IoScheduler对象。

这里还有一个问题，f==null这个条件什么时候不成立呢？当然是我们想要自己处理传入的Callable对象了。那要如何自己处理呢？我们自己声明一个继承自Function接口的处理类，并实现接口中的apply方法（当然了这里面最终肯定是要调用call()方法返回Scheduler对象的，我们可以在返回之前做一些自己的处理），然后调用onInitIoHandler的静态Setter方法（RxJavaPlugins类中的成员变量都是静态的，因此其Setter和Getter方法也都是静态的）为onInitIoHandler赋值，此时由于onInitIoHandler是不为null的，因此f==null不成立，自然就执行下面的方法，我们简要的看下代码：

@NonNull
static Scheduler applyRequireNonNull(@NonNull Function, ? extends Scheduler> f, Callable s) {
    //这里调用apply(f, s)，f为我们自定义的处理类对象
    return ObjectHelper.requireNonNull(apply(f, s), "Scheduler Callable result can't be null");
}

@NonNull
static  R apply(@NonNull Function f, @NonNull T t) {
    try {
        //调用f中的apply方法，也就是我们自己定义的处理方法，t为Callable对象
        return f.apply(t);
    } catch (Throwable ex) {
        throw ExceptionHelper.wrapOrThrow(ex);
    }
}

至此，我们可以回答前面的问题了，Schedulers.io()返回的就是一个IoScheduler对象，这个IoScheduler实际上就是在IO线程调度时用来管理IO线程的。

scheduler.scheduleDirect(new SubscribeTask(parent))具体是如何完成线程调度的？

我们点进这个方法看一下：

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

直接无延迟调用了scheduleDirect方法

@NonNull
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    //1、创建一个worker，其实现了Disposable接口，是一个工作者类
    final Worker w = createWorker();
    //2、这里我们可能要对run参数做一些处理，也可能不处理，取决为我们是否为RxJavaPlugins类的成员变量onScheduleHandler赋值（自定义继承Function的实现类处理run）。
    //一般情况下我们可以认为decoratedRun=run。
    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
    //3、包装类。DisposeTask实现了Disposable, Runnable, SchedulerRunnableIntrospection这三个接口，        
    //主要用于管理任务Runnable及其工作Worker
    DisposeTask task = new DisposeTask(decoratedRun, w);
    //4、开始执行任务
    w.schedule(task, delay, unit);
    //5、返回这个管理者
    return task;
}

上面的方法将外面传入进来的run传递给了DisposeTask，然后调用worker来进行任务调度，看起来主要的任务是在DisposeTask里面执行的，我看下DisposeTask这个类的代码：

static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {
    //6、外部传进来的Runnable任务
    final Runnable decoratedRun;
    //7、调度工作者worker
    final Worker w;
    //8、当前线程
    Thread runner;

    DisposeTask(Runnable decoratedRun, Worker w) {
        this.decoratedRun = decoratedRun;
        this.w = w;
    }

    @Override
    public void run() {
        //9、保存decoratedRun执行时候所在的线程
        runner = Thread.currentThread();
        try {
            //10、执行decoratedRun的run()方法
            decoratedRun.run();
        } finally {
            dispose();
            runner = null;
        }
    }

    @Override
    public void dispose() {
        if (runner == Thread.currentThread() && w instanceof NewThreadWorker) {
            //11、当DisposeTask被取消执行任务时，如果取消任务时所在的线程和decoratedRun任务执行时所在的线程为同一个线程，
            //并且调度工作者worker类型为NewThreadWorker类型，直接结束任务，关闭底层执行程序（这里是同步任务场景）
            ((NewThreadWorker)w).shutdown();
        } else {
            //12、当DisposeTask被取消执行任务时，告诉worker工作者取消调度任务（IO异步任务场景）
            w.dispose();
        }
    }

    @Override
    public boolean isDisposed() {
        return w.isDisposed();
    }

    @Override
    public Runnable getWrappedRunnable() {
        return this.decoratedRun;
    }
}

具体的步骤都在上面的代码中标注了出来，我们可以看到，在DisposeTask的run方法中最终执行了decoratedRun.run()，而这个decoratedRun也就是我们在ObservableSubscribeOn类的subscribeActual(final Observer s)方法里面所执行的代码parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)))传进来的new SubscribeTask(parent))对象，通过本文前面的分析我们知道，SubscribeTask也是一个Runnable，实际上的订阅source.subscribe(parent)正是在其run()方法中。

至此我们明白了scheduler.scheduleDirect(new SubscribeTask(parent))都做了哪些工作，还有一个问题，我们通过查看Worker类的源码会发现这是一个抽象类，而createWorker方法也是一个抽象方法，我们在上面说到在IO线程调度时实际上管理IO线程的是IoScheduler，这个类也是继承自Scheduler，我们去IoScheduler类看下createWorker方法：

public Worker createWorker() {
    return new EventLoopWorker(pool.get());
}

该方法直接返回了EventLoopWorker对象（管理Worker--负责任务调度的工作者，CachedWorkerPool--管理Worker的一个队列，CompositeDisposable--批量管理订阅状态的disposable容器 ）：

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();
        this.threadWorker = pool.get();
    }

    //取消订阅时，释放当前的threadWorker 
    @Override
    public void dispose() {
        //如果成功的将disposed状态设置为true，则取消订阅，并将释放当前的threadWorker资源，并将其添加到Worker管理池中
        if (once.compareAndSet(false, true)) {
            tasks.dispose();

            // releasing the pool should be the last action
            pool.release(threadWorker);
        }
    }

    @Override
    public boolean isDisposed() {
        return once.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;
        }
        //实际线程调度工作
        return threadWorker.scheduleActual(action, delayTime, unit, tasks);
    }
}

虽然EventLoopWorker也继承了Scheduler的内部类Worker，但在scheduler方法中，把实际的线程调度工作转发给了ThreadWorker去进行，ThreadWorker又继承了NewThreadWorker类，我们点进scheduleActual(action, delayTime, unit, tasks)方法看下（该方法位于NewThreadWorker类中）：

@NonNull
public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
    Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
    //1、包装类，管理任务线程，内部实现了一系列方法，包括线程任务的执行，设置任务标志位，任务的取消等。
    //这个parent参数就是我们平常使用的CompositeDisposable对象，负责订阅批量管理
    ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

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

    Future f;
    try {
        //2、将任务线程ScheduledRunnable放入线程池执行任务，根据是否有延迟时间调用相应的方法
        if (delayTime <= 0) {
            f = executor.submit((Callable)sr);
        } else {
            f = executor.schedule((Callable)sr, delayTime, unit);
        }
        //3、设置ScheduledRunnable在线程池中的执行状态
        sr.setFuture(f);
    } catch (RejectedExecutionException ex) {
        if (parent != null) {
            //4、如果ScheduledRunnable在执行过程中出错，并且有设置订阅状态管理容器，将ScheduledRunnable的订阅状态从该容器中移除
            parent.remove(sr);
        }
        RxJavaPlugins.onError(ex);
    }
    //5、返回任务线程包装类给外部，用于该任务的管理
    return sr;
}
 
 
既然返回的是ScheduledRunnable对象，我们就来看下这个类：
 
 
//这里即实现了Runnable接口也实现了Callable接口，用于应对需要返回值和不需要返回值的情况
public final class ScheduledRunnable extends AtomicReferenceArray implements Runnable, Callable, Disposable {

    private static final long serialVersionUID = -6120223772001106981L;
    final Runnable actual;

    /** Indicates that the parent tracking this task has been notified about its completion. */
    static final Object PARENT_DISPOSED = new Object();
    /** Indicates the dispose() was called from within the run/call method. */
    static final Object SYNC_DISPOSED = new Object();
    /** Indicates the dispose() was called from another thread. */
    static final Object ASYNC_DISPOSED = new Object();

    static final Object DONE = new Object();
    //保存追踪该任务的外部任务状态的标识
    static final int PARENT_INDEX = 0;
    //保存该任务运行状态的标识
    static final int FUTURE_INDEX = 1;
    //保存其他线程像该任务发出的指令标识
    static final int THREAD_INDEX = 2;

    /**
     * Creates a ScheduledRunnable by wrapping the given action and setting
     * up the optional parent.
     * @param actual the runnable to wrap, not-null (not verified)
     * @param parent the parent tracking container or null if none
     */
    public ScheduledRunnable(Runnable actual, DisposableContainer parent) {
        super(3);
        this.actual = actual;
        //如果我们在外部通过一个disposable容器来管理当前任务，就保存这个disposable容器
        this.lazySet(0, parent);
    }

    @Override
    public Object call() {
        // Being Callable saves an allocation in ThreadPoolExecutor
        run();
        return null;
    }

    @Override
    public void run() {
        //设置任务执行线程为当前所在线程
        lazySet(THREAD_INDEX, Thread.currentThread());
        try {
            try {
                //执行实际IO任务
                actual.run();
            } catch (Throwable e) {
                // Exceptions.throwIfFatal(e); nowhere to go
                RxJavaPlugins.onError(e);
            }
        } finally {
            //任务执行期间出现错误，重置当前执行线程为null
            lazySet(THREAD_INDEX, null);
            //获取追踪次任务的外部任务状态
            Object o = get(PARENT_INDEX);
            if (o != PARENT_DISPOSED && compareAndSet(PARENT_INDEX, o, DONE) && o != null) {
                //如果追踪该任务状态的外部任务还没有被终止，将它设置为DONE状态，并将当前任务从订阅状态管理容器中删除
                ((DisposableContainer)o).delete(this);
            }

            //任务在执行出错时，确保任务的执行结果状态为SYNC_DISPOSED，ASYNC_DISPOSED以及DONE中的任意一个即可
            for (;;) {
                o = get(FUTURE_INDEX);
                if (o == SYNC_DISPOSED || o == ASYNC_DISPOSED || compareAndSet(FUTURE_INDEX, o, DONE)) {
                    break;
                }
            }
        }
    }

    //设置Runnable任务的运行状态
    public void setFuture(Future f) {
        for (;;) {
            Object o = get(FUTURE_INDEX);
            if (o == DONE) {
                return;
            }
            if (o == SYNC_DISPOSED) {
                f.cancel(false);
                return;
            }
            if (o == ASYNC_DISPOSED) {
                f.cancel(true);
                return;
            }
            if (compareAndSet(FUTURE_INDEX, o, f)) {
                return;
            }
        }
    }

    //结束Runnable任务运行
    @Override
    public void dispose() {
        for (;;) {
            //获取任务运行状态
            Object o = get(FUTURE_INDEX);
            //如果任务执行结果状态为以下三个状态中的任意一个，表示任务已被结束，什么也不做
            if (o == DONE || o == SYNC_DISPOSED || o == ASYNC_DISPOSED) {
                break;
            }
            //判断任务在执行期间所在的线程以及执行终止后所在的线程是否一致
            boolean async = get(THREAD_INDEX) != Thread.currentThread();
            //设置该任务是在同步环境下结束的还是在异步环境下结束的
            if (compareAndSet(FUTURE_INDEX, o, async ? ASYNC_DISPOSED : SYNC_DISPOSED)) {
                if (o != null) {
                    //取消任务的执行
                    ((Future)o).cancel(async);
                }
                break;
            }
        }
       
        for (;;) {
            //获取追踪该任务的外部任务所处状态
            Object o = get(PARENT_INDEX);
            if (o == DONE || o == PARENT_DISPOSED || o == null) {
                //如果外部任务状态是终止状态，则什么也不做
                return;
            }
            if (compareAndSet(PARENT_INDEX, o, PARENT_DISPOSED)) {
                //如果外部任务状态不是终止状态，将其设置为终止状态，并将当前任务从状态容器中移除
                ((DisposableContainer)o).delete(this);
                return;
            }
        }
    }

    //根据追踪该任务的父任务状态并根据父任务是否结束来判断该任务是否结束
    @Override
    public boolean isDisposed() {
        Object o = get(PARENT_INDEX);
        return o == PARENT_DISPOSED || o == DONE;
    }
}
 
 
通过上面代码我们可以看到，NewThreadWorker类内部确实是通过线程池来执行我们提交的IO任务，这个线程池是什么时候创建的呢？答案是在createWorker()方法调用的时候，即我们创建worker工作者对象时。通过调用EventLoopWorker的构造方法生成该对象并返回。
 
 
EventLoopWorker(CachedWorkerPool pool) {
    this.pool = pool;
    this.tasks = new CompositeDisposable();
    this.threadWorker = pool.get();
}

 
 
这个构造方法接收一个CachedWorkerPool类型的参数，这个CachedWorkerPool并不是线程池，而是用来管理我们创建的Worker工作者。
 
 
static final class CachedWorkerPool implements Runnable {
    //空闲Worker在队列中的存活时间
    private final long keepAliveTime;
    //线程安全的任务队列，用于保存处于空闲状态的Worker工作者
    private final ConcurrentLinkedQueue expiringWorkerQueue;
    //Disposable容器，可以用于统一管理多个订阅任务状态
    final CompositeDisposable allWorkers;
    //可以实现循环或延时执行任务的线程池
    private final ScheduledExecutorService evictorService;
    //保存延迟周期任务
    private final Future evictorTask;
    //线程创建工厂方法
    private final ThreadFactory threadFactory;

    CachedWorkerPool(long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory) {
        this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
        this.expiringWorkerQueue = new ConcurrentLinkedQueue();
        this.allWorkers = new CompositeDisposable();
        this.threadFactory = threadFactory;

        ScheduledExecutorService evictor = null;
        Future task = null;
        //如果空闲队列中的Worker有存活时间，则创建线程池和相应的延迟周期任务
        //该类实现了Runnable接口，并在run()方法中调用方法evictExpiredWorkers()，用于移除空闲队列中超过设置的存活时间的Worker
        if (unit != null) {
            //创建线程池
            evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
            //并将当前Runnable任务对象（即CachedWorkerPool）添加到周期延迟执行任务中，然后启动线程池执行该周期延迟任务，最后返回执行结果
            //由于run()方法中主要是为了在周期时间内检查Worker空闲队列中缓存的Worker是否超过存活时间，因此此处周期延迟任务的延迟时间与Worker的存活时间一致
            task = evictor.scheduleWithFixedDelay(this, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS);
        }
        evictorService = evictor;
        evictorTask = task;
    }

    //CachedWorkerPool内部的线程池启动后开始执行
    @Override
    public void run() {
        evictExpiredWorkers();
    }

    //从空闲队列中取出一个缓存的工作者Worker
    ThreadWorker get() {
        if (allWorkers.isDisposed()) {
            return SHUTDOWN_THREAD_WORKER;
        }
        while (!expiringWorkerQueue.isEmpty()) {
            ThreadWorker threadWorker = expiringWorkerQueue.poll();
            if (threadWorker != null) {
                return threadWorker;
            }
        }

        //如果队列中没有缓存的Worker，则新建一个，并将其添加到disposable容器中，便于订阅任务的统一管理
        ThreadWorker w = new ThreadWorker(threadFactory);
        allWorkers.add(w);
        return w;
    }

    //释放一个ThreadWorker，并为其设置存活时间，将其添加到空闲队列中
    void release(ThreadWorker threadWorker) {
        // Refresh expire time before putting worker back in pool
        threadWorker.setExpirationTime(now() + keepAliveTime);
        expiringWorkerQueue.offer(threadWorker);
    }

    //移除空闲队列中所有超过存活时间（keepAliveTime）的Worker
    void evictExpiredWorkers() {
        if (!expiringWorkerQueue.isEmpty()) {
            long currentTimestamp = now();

            for (ThreadWorker threadWorker : expiringWorkerQueue) {
                if (threadWorker.getExpirationTime() <= currentTimestamp) {
                    if (expiringWorkerQueue.remove(threadWorker)) {
                        allWorkers.remove(threadWorker);
                    }
                } else {
                    // Queue is ordered with the worker that will expire first in the beginning, so when we
                    // find a non-expired worker we can stop evicting.
                    break;
                }
            }
        }
    }
    //......代码省略
}

 
 
在get()方法中，先检查空闲队列有没有缓存的Worker，如果没有则创建一个。
 
 
static final class ThreadWorker extends NewThreadWorker {
        private long expirationTime;

        ThreadWorker(ThreadFactory threadFactory) {
            super(threadFactory);
            this.expirationTime = 0L;
        }
        //......代码省略
    }

 
 
ThreadWorker继承自NewThreadWorker，虽然它们的名字都带了Thread，但它们并不是线程，而是一个调度订阅任务的工作者，NewThreadWorker继承自Scheduler内的一个内部类--Worker。
 
 
public class NewThreadWorker extends Scheduler.Worker implements Disposable {
    private final ScheduledExecutorService executor;

    volatile boolean disposed;

    public NewThreadWorker(ThreadFactory threadFactory) {
        executor = SchedulerPoolFactory.create(threadFactory);
    }
    //......代码省略
}

 
 
我们看到创建线程池的代码了，继续点进去看下：
 
 
//SchedulerPoolFactory.create
public static ScheduledExecutorService create(ThreadFactory factory) {
    final ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, factory);
    if (PURGE_ENABLED && exec instanceof ScheduledThreadPoolExecutor) {
        ScheduledThreadPoolExecutor e = (ScheduledThreadPoolExecutor) exec;
        POOLS.put(e, exec);
    }
    return exec;
}

//Executors.newScheduledThreadPool
public static ScheduledExecutorService newScheduledThreadPool(
        int corePoolSize, ThreadFactory threadFactory) {
    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}

//new ScheduledThreadPoolExecutor
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE,
            DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
            new DelayedWorkQueue(), threadFactory);
}

 
 
这里创建了一个线程池，其核心线程数为1，可创建的最大线程为Integer.MAX_VALUE，非核心线程在线程池中的存活时间为10，存活时间单位为MILLISECONDS，线程管理队列为DelayedWorkQueue，线程创建的工厂类为我们外面传入的工厂类（这里是RxJava默认实现的工厂类==>RxThreadFactory）。
 最后NewThreadWorker就是通过这里创建的线程池来执行具体的IO任务==>SubscribeTask。
 
 
由上面代码可以看到，每个Worker内部都自己创建了一个独立的线程池来执行IO任务，这些Worker又都是通过CachedWorkerPool来统一管理的，那么这个CachedWorkerPool又是什么时候创建的呢？答案是在我们调用Schedulers.io()时。
 前面我们提到过，当调用Schedulers.io()时，最终会调用IoScheduler类的构造方法产生一个IoScheduler对象。
 
 
public final class IoScheduler extends Scheduler {
    //......代码省略
    private static final String WORKER_THREAD_NAME_PREFIX = "RxCachedThreadScheduler";
    static final RxThreadFactory WORKER_THREAD_FACTORY;
    static final CachedWorkerPool NONE;
    
static {
        //......代码省略
        //创建线程的工厂类，为每个创建的线程名添加前缀（RxCachedThreadScheduler）
        WORKER_THREAD_FACTORY = new RxThreadFactory(WORKER_THREAD_NAME_PREFIX, priority);
        //初始化一个没有线程池的CachedWorkerPool，该Worker管理池内空闲队列中的Worker存活时间为0，Worker内部线程池创建线程的工厂类为RxThreadFactory
        NONE = new CachedWorkerPool(0, null, WORKER_THREAD_FACTORY);
        //清空CachedWorkerPool内部状态
        NONE.shutdown();
    }

    public IoScheduler() {
        this(WORKER_THREAD_FACTORY);
    }
    
    public IoScheduler(ThreadFactory threadFactory) {
        //创建线程的工厂类对象
        this.threadFactory = threadFactory;
        //包装类，以保证多线程环境下CachedWorkerPool可以正常工作
        this.pool = new AtomicReference(NONE);
        start();
    }

    public void start() {
        //新建一个有线程池以及Worker存活时间的CachedWorkerPool
        CachedWorkerPool update = new CachedWorkerPool(KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT, threadFactory);
        //这里通过AtomicReference的CAS方法来确保NONE能被正常更新为update
        if (!pool.compareAndSet(NONE, update)) {
            update.shutdown();
        }
    }

    //......代码省略
}

 
 
至此：订阅线程切换也就告一段落了，文章的后面还扯了很多题外话，下一篇文章RxJava2笔记（四、观察者线程切换）我们继续介绍观察者线程切换（即如何将线程由子线程切换回主线程从而进行UI更新）。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(RxJava2笔记（三、订阅线程切换）)

        

            

                
    
                    
  • 深入解析C++静态关键字：生命周期、存储管理与C++11线程安全实现
                        zzr915
c++
                        
    目录1、静态关键字的作用2、静态关键字的使用规则2.1存储位置2.2初始化机制3、静态局部变量的线程安全性解析3.1C++11及之后的线程安全机制3.2C++11之前的风险3.3关键注意事项4、总结1、静态关键字的作用静态关键字（static）可调整变量的生存周期，使其与程序生命周期一致。例如：classInt{intvalue;public:Int(intx=0):value(x){coutda
    
                    
    • 
                    
  • 13.二叉树所有路径
                        Vacant Seat
java数据结构算法b树
                        
    二叉树所有路径因为要从根节点到叶子节点，所以使用前序遍历（中左右）这道题目涉及到回溯问题，因为需要把路径记下来，需要回溯来回退一个路径再进入另一个路径先使用递归的方式，来做前序遍历。递归三部曲：递归函数的参数和返回值要传入根节点，记录每一条路径的path，和存放结果集的result，不需要返回值确定递归终止条件遇到叶子节点就返回，所以if(cur.left==null&&cur.right==nu
    
                    
    • 
                    
  • 双指针-三数之和
                        Vacant Seat
排序算法算法数据结构
                        
    三数之和给你一个整数数组nums，判断是否存在三元组[nums[i],nums[j],nums[k]]满足i!=j、i!=k且j!=k，同时还满足nums[i]+nums[j]+nums[k]==0。请你返回所有和为0且不重复的三元组。注意：答案中不可以包含重复的三元组。输入：整型数组输出：二元列表思路：先对数组进行排序，然后循环排序后的数组，再定义双指针，进行移动，关键是对于去重的操作，clas
    
                    
    • 
                    
  • 【Linux】【网络】Reactor模式
                        钟离墨笺
Linuxlinux网络java
                        
    【Linux】【网络】Reactor模式1.Reactor模式：Reactor模式是一种事件驱动的设计模式，同步I/O通常用于设置Reactor模式主线程(I/0处理单元，下同)只负责监听文件描述上是否有事件发生，有的话就立即将该事件通知工作线程(逻辑单元，下同)。除此之外，主线程不做任何其他实质性的工作。读写数据，接受新的连接，以及处理客户请求均在工作线程中完成。使用同步I/O模型(以epoll
    
                    
    • 
                    
  • 【Perl脚本】第三部分：Perl数据结构
                        今天你芯动了吗
perl数据结构scala
                        
    系列文章目录文章目录系列文章目录标量数组散列Perl有且只有3种变量类型：标量（saclar）、数组（array）和散列（hash）标量使用my来声明标量，变量存储的内容可以是字符串，数字，引用，文件句柄等等，而且同一个标量可以先存储数字，然后存储字符串。注意：Perl的一些内建变量由全大写字母组成，所以我们最好避免创建全大写字母的变量名变量区分大小写，$abc和$Abc是两个变量标量赋值使用等号
    
                    
    • 
                    
  • Java 基于 SpringBoot+Vue 的动漫平台（附源码，文档）
                        程序员徐师兄
javaspringbootvue.js动漫平台动漫网站
                        
    博主介绍：✌程序员徐师兄、8年大厂程序员经历。全网粉丝12w+、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战*✌文末获取源码联系精彩专栏推荐订阅不然下次找不到哟2022-2024年最全的计算机软件毕业设计选题大全：1000个热门选题推荐✅Java项目精品实战案例《500套》Java微信小程序项目实战《200套》Python项目实战《200套
    
                    
    • 
                    
  • 学习笔记分享-快速掌握前端-html进阶（利用telnet发送json请求、利用telnet发送multipart请求）
                        2301_81243975
前端学习笔记
                        
    前言图片上面的personal表示只有图片上面的一行语句是解释图片内容的、local表示这个图片所在标题下的所有语句都是解释图片内容的、global表示有多个标题下的所有语句都是解释图片内容的我是一名大二的学生，学了差不多一年java技术栈了，想记录一下自己对知识点的心得，目前还是个小白，期望大佬们可以指出我笔记中的不足之处、对知识点的认知错误、笔记结构的混乱等这些图片内容都是在观看黑马课程时的视
    
                    
    • 
                    
  • 学习笔记分享-数据结构与算法-图-Dijkstra（算法描述、算法实现）
                        2301_81243975
算法学习笔记
                        
    前言图片上面的personal表示只有图片上面的一行语句是解释图片内容的、local表示这个图片所在标题下的所有语句都是解释图片内容的、global表示有多个标题下的所有语句都是解释图片内容的我是一名大二的学生，学了差不多一年java技术栈了，想记录一下自己对知识点的心得，目前还是个小白，期望大佬们可以指出我笔记中的不足之处、对知识点的认知错误、笔记结构的混乱等这些图片内容都是在观看黑马课程时的视
    
                    
    • 
                    
  • 双指针-接雨水
                        Vacant Seat
java数据结构算法
                        
    接雨水给定n个非负整数表示每个宽度为1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。输入：整型数组输出：整型变量思路：一层一层的计算水量，会超出时间限制按列求，分为三种情况，当前列与左右两边最大的列的较小值进行比较，只有当前列小于较小值，当前列才会接到水.也会超出时间限制动态规划，不需要每次都求出左边和右边的最大值，可以将最大值存储到两个数组之中，就可以解决时间复杂度的问题双指针，在第
    
                    
    • 
                    
  • 鸿蒙应用开发系列 EX篇：HarmonyOS应用开发者基础认证
                        李小白杂货铺
斜杠人生harmonyos华为鸿蒙系统应用开发者基础认证鸿蒙应用开发鸿蒙系统应用开发
                        
    文章目录系列文章背景认证考试题库参考注意：题库会不定时的进行具备调整甚至整体轮换，此为2024.5月版本注意：题库中题目的选项每次都会随机顺序，请参考内容判断题单选题多选题系列文章鸿蒙应用开发系列篇一：鸿蒙系统概述鸿蒙应用开发系列篇二：鸿蒙系统开发工具与环境鸿蒙应用开发系列篇三：ArkTS语言鸿蒙应用开发系列篇四：鸿蒙系统应用开发基础鸿蒙应用开发系列篇五：鸿蒙系统高级开发技术鸿蒙应用开发系列篇六：
    
                    
    • 
                    
  • Hive中文乱码解决方法
                        快乐骑行^_^
大数据大数据平台二次开发
                        
    Hive中文乱码解决方法一、Hive中文乱码原因二、Hive中文乱码解决方法三、修改hive配置文件四、再次查看表信息，中文注释正常一、Hive中文乱码原因hive的元数据是由mysql管理的，mysql默认编码是latin1，中文存储进去容易乱码，所以最好把mysql的编码改成utf-8二、Hive中文乱码解决方法需要把相应注释的地方的字符集由latin1改成utf-8，用到注释的就三个地方，表
    
                    
    • 
                    
  • Nginx 如何实现请求的缓存过期策略？
                        zengson_g
Nginxnginx缓存运维服务器网络
                        
    关注博主️带你畅游技术世界，不错过每一次成长机会！文章目录Nginx如何实现请求的缓存过期策略？一、缓存的重要性与基本概念二、Nginx缓存过期策略的原理三、设置Nginx缓存过期时间四、基于变量的动态缓存过期策略五、使用第三方模块增强缓存功能六、缓存的更新与失效机制七、缓存命中率与性能监控八、实际应用中的注意事项Nginx如何实现请求的缓存过期策略？在当今快节奏的互联网世界中，网站和应用的性能优
    
                    
    • 
                    
  • 【HarmonyOS之旅】基于ArkTS开发(三) -＞ 兼容JS的类Web开发(四) -＞ 常见组件(二) -＞ tabs
                        枫叶丹4
HarmonyOS前端javascript开发语言harmonyos华为华为云
                        
    目录1->创建Tabs2->设置Tabs方向3->设置样式4->显示页签索引5->场景示例1->创建Tabs在pages/index目录下的hml文件中创建一个Tabs组件。item1item2content1content2/*test.css*/.container{flex-direction:column;justify-content:center;align-items:center;
    
                    
    • 
                    
  • 【Java线程中断】线程中断后为什么要调用interrupt()?
                        星星点点洲
Javajava
                        
    我们在处理中断异常时InterruptedException，往往会调用Thread.currentThread().interrupt()，你知道这么做的目的和用处吗？这是Java多线程编程中一个重要的实践，主要原因有以下：interrupt为了继续传递中断信号1.恢复中断状态当线程在阻塞方法（如sleep()、wait()、join()）中被中断时，JVM会做两件事：抛出Interrupted
    
                    
    • 
                    
  • Android开发笔记: 5种对话框案例
                        程序猿的杂货店
Android开发笔记android开发笔记PopupWindowAlertDialogProgressDialog
                        
    5种android对话框1弹出普通对话框---系统更新2自定义对话框--用户登录3时间选择对话框--时间对话框4进度条对话框--信息加载..5popuWindow对话框下载地址:http://download.csdn.net/download/taoerit/99651421弹出普通对话框---系统更新//弹出普通对话框publicvoidshowNormalDialog(Viewv){Aler
    
                    
    • 
                    
  • 模型/视图编程
                        潦潦
Qtqt开发语言
                        
    1.MVC包含模型（Model表示数据）、视图（View用户界面）、控制器（Controller界面对用户输入的反应方式）三部分，Qt中还引入了委托(Delegate，又称代理)来对用户输入进行灵活处理，使用它可以定制数据的渲染和编辑方式。QAbstractItemModel是模型的抽象基类TheQAbstractItemModelclassprovidestheabstractinterface
    
                    
    • 
                    
  • web第三次作业
                        naodianbozzz
前端cssjavascript
                        
    实现网页登入窗口的显示隐藏登录窗口滑动效果*{margin:0;padding:0;box-sizing:border-box;}html,body{width:100%;height:100%;}.container{width:100%;height:100%;background-color:#f2f1f2;}header{width:1200px;height:50px;backgroun
    
                    
    • 
                    
  • Qt模型/视图结构
                        十年编程老舅
QT开发qtqt开发Qt模型qt教程C++
                        
    MVC设计模式是起源于Smalltalk的一种与用户界面相关的设计模式。通过使用此模式，可以有效地分离数据和用户界面。MVC设计模式包括三个元素：表示数据的模型（Model）、表示用户界面的视图（View）和定义了用户在界面上操作的控制器（Controller）。与MVC设计模式类似，Qt引入了模型/视图结构用于完成数据与界面的分离，即InterView框架。但不同的是，Qt的InterView框
    
                    
    • 
                    
  • 【性能测试】如何理解“10个线程且10次循环“的请求和“100线程且1次循环“的请求
                        朱公子的Note
如何理解线程且循环的请求jmeter
                        
    在性能测试中，我们常常会见到不同的并发配置：比如“10个线程且10次循环”与“100线程且1次循环”。乍一看，这两个设置的总请求数都是100次，但它们对系统的压力和测试场景却截然不同。了解其中的区别，能帮助你更精准地模拟真实用户负载，提升性能测试的实战效果。在实际业务中，不同的应用场景要求系统既要应对持续稳定的流量，也需要在突发流量下保持稳定。通过不同的线程与循环配置，我们可以灵活地模拟这些场景，
    
                    
    • 
                    
  • 线程池代码分析及延申应用
                        埃菲尔铁塔_CV算法
c++算法开发语言人工智能opencv机器学习
                        
    代码功能概述这段C++代码实现了一个简单的线程池类MthreadPool，线程池是一种用于管理和复用线程的机制，它可以避免频繁创建和销毁线程带来的开销，提高程序的性能。MthreadPool类允许用户指定线程池的最小和最大线程数，并提供了添加任务、管理线程数量等功能。代码详细解释1.类的定义和成员变量#include"MthreadPool.h"MthreadPool::MthreadPool(i
    
                    
    • 
                    
  • 轮播图html
                        The_era_achievs_hero
html前端javascript
                        
    题十二：轮播图要求：1.鼠标不在图片上方时，进行自动轮播，并且左右箭头不会显示；当鼠标放在图片上方时，停止轮播，并且左右箭头会显示；2.图片切换之后，图片中下方的小圆点会同时进行切换，并且点击相应的小圆点可以切换到相应的图片上；3.点击左右箭头可以进行左右图片的切换；4.图片上需有介绍的文字，会随图片切换一起进行切换。原理：当鼠标进入时，左走箭头出现，定时器关闭，离开时，箭头消失，定时器开启。写D
    
                    
    • 
                    
  • 省市区三级联动
                        The_era_achievs_hero
javalinux数据库
                        
    题十一：省市区三级联动要求：通过三个下拉菜单的联动来实现，第一级下拉菜单为省级，第二级下拉菜单为市级，第三级下拉菜单为区级。当点击第一级下拉菜单，第二级菜单的内容会自动匹配；选择第二级菜单时，第三级菜单会自动生成。当我取消上一级菜单的选项时，次一级选项会自动消失。原理：架构出三个选择的框架，用change分别监听provice和city表单元素值的变化。通过获取实时的值来改变下一级里面的内容，新增
    
                    
    • 
                    
  • 第十八篇
                        zch001104

                        
    首页新闻博问专区闪存班级我的博客我的园子账号设置退出登录注册登录个人公众号交流：bigsaibigsai博客园首页新随笔联系订阅管理随笔-46文章-0评论-67八大排序算法—16张图搞懂基数排序原创公众号：bigsai转载需联系笔者前言在排序算法中，大家可能对桶排序、计数排序、基数排序不太了解，不太清楚其算法的思想和流程，也可能看过会过但是很快就忘记了，但是不要紧，幸运的是你看到了本篇文章。本文将
    
                    
    • 
                    
  • 七.工控之工控机专题
                        小何的Blog
工控工控工控机C#上位机
                        
    1.防止工控机突然断电导致数据丢失防止工控机突然断电问题后，数据无法及时保存在磁盘问题，可以有如下2种举措：安装UPS电源。添加磁盘阵列功能。2.CPU选择Intel的E系列CPU是服务器专用，主打超长时间稳定运行，多线程任务处理，而Intel的I系列CPU是桌面级的，主打游戏娱乐、办公设计。这个是完全不同的两个产品线，没有好坏之分，服务器就E，普通电脑就I。因此在工业领域，尤其是一些对电脑、系统
    
                    
    • 
                    
  • 多线程并发模拟实现与分析：基于Scapy的TCP SYN洪水攻击实验研究
                        键盘侠伍十七
tcp/ip网络协议网络网络安全pythonsynflood
                        
    简介实现基于Python实现的多线程TCPSYN洪水攻击。该实例利用Scapy库构造并发送TCPSYN数据包，通过多线程技术模拟并发的网络攻击行为。实现原理SYNFlood攻击是一种经典的分布式拒绝服务（DDoS）攻击方式，利用了TCP协议握手过程中的弱点。TCP三次握手过程在正常情况下，TCP建立连接需要经过以下三个步骤的交互：客户端发送SYN：客户端向服务器发送一个同步（SYN）段，其中包含客
    
                    
    • 
                    
  • uniapp 封装进度条组件
                        sunyin.liu
uniappiviewuni-app
                        
    一、素材准备（5张图片，第一张高亮图、第二张灰色、第二张高亮、第三张灰色、第四张高亮）免费给大家，本人自己设计的。链接：https://pan.baidu.com/s/18sz5ORSYuPbf_4fpureRMQ提取码：bpyj如果链接失效了，请在底下评论，看到会马上更新。二、写啥废话，直接代码上封装的组件代码1.先引入uview-ui,uniapp不懂引入uview-u组件的自行移步到官网。很
    
                    
    • 
                    
  • 数字化转型实战：Odoo+工业物联网技术破解江苏食品制造行业三大核心痛点
                        邹工转型手札
风吟九宵Duodoo开源企业信息化运维人工智能制造
                        
    行业背景与挑战江苏省作为中国食品工业产值前三强省份，拥有光明乳业、雨润食品等龙头企业及近2000家中小型食品制造企业。2023年江苏省食品工业协会调研显示：行业平均设备综合效率（OEE）仅为62.3%月度异常停机时间达42小时/产线质量追溯周期超过3.5小时库存周转天数高于行业标杆企业27%在实地调研南京某糕点生产企业时发现，其ERP系统与生产设备存在严重数据断层：车间主任需每天手工录入6类表单、
    
                    
    • 
                    
  • matlab中功率因数怎样测量,如何测量功率因数?功率因数测量方法
                        liubotian1995
matlab中功率因数怎样测量
                        
    功率因数测量方法有：1、功率因数表法直接测量。用功率因数表直接测即可。这样测量到的瞬时功率因数值。2、功率法测量：测量负载的有功功率和无功功率(也有测视在功率的)，在用勾股定理或三角函数计算出功率因数，这是依据功率因数的定义得出的测量方法。数据也是瞬时功率因数值。3、电量法测量：供电局使用的方法，抄录当期用电的有功电量和无功电量数据，用三角函数计算出功率因数值。这是当期的平均功率因数值。我们都知道
    
                    
    • 
                    
  • 使用TimerTask实现定时任务
                        Yvonne978
java开发语言
                        
    实现定时任务，需要解决三个问题：1.任务是什么，即干什么？2.如何执行？什么时候开始执行？执行频率？3.使用什么框架执行？这里使用轻量Spring自带的TimerTask进行实现一、编写任务新建一个类如MyThread，继承TimerTask，重写run方法packagecom.icfcc.cnaps2.thread;importjava.util.TimerTask;publicclassMyT
    
                    
    • 
                    
  • 【Three.js】四（1）、three.js中的光源——基础光源
                        MAXLZ
【WebGL】Three.jsthree.js光源AmbientLightPointLightSpotLight
                        
    【Three.js】四（1）、three.js中的光源——基础光源一、THREE.AmbientLight二、THREE.PointLight2.1THREE.PointLight属性三、THREE.SpotLight3.1THREE.SpotLight属性四、THREE.DirectionalLight4.1THREE.DirectionalLight的属性three.js中的光源有：THREE
    
                    
    • 
                                
  • LeetCode[位运算] - #137 Single Number II
                                    Cwind
javaAlgorithmLeetCode题解位运算
                                    
    原题链接：#137 Single Number II  
要求： 
给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 
注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间 
  
难度：中等 
  
分析： 
与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
    
                                
    • 
                                
  • 《JavaScript语言精粹》笔记
                                    aijuans
JavaScript
                                    
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 
1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 
2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
    
                                
    • 
                                
  • 你应该更新的Java知识之常用程序库
                                    Kai_Ge
java
                                    
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 
Guava 
Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 
guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
    
                                
    • 
                                
  • HttpClient
                                    120153216
httpclient
                                    
    /**
 * 可以传对象的请求转发，对象已流形式放入HTTP中
 */
public static Object doPost(Map<String,Object> parmMap,String url)
	{
		Object object = null;
		HttpClient hc = new HttpClient();
		
		String fullURL 
    
                                
    • 
                                
  • Django model字段类型清单
                                    2002wmj
django
                                    
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段)  BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。  Cha
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗CPU最多的SQL
                                    357029540
SQL Server
                                    
    返回消耗CPU数目最多的10条语句 
 
SELECT TOP 10 
   total_worker_time/execution_count AS avg_cpu_cost, plan_handle, 
   execution_count, 
   (SELECT SUBSTRING(text, statement_start_of
    
                                
    • 
                                
  • Myeclipse项目无法部署，Undefined exploded archive location
                                    7454103
eclipseMyEclipse
                                    
    做个备忘！ 
 
错误信息为： 
      Undefined exploded archive location 
 
 
原因： 
          在工程转移过程中，导致工程的配置文件出错； 
 
 
解决方法： 
   
    
                                
    • 
                                
  • GMT时间格式转换
                                    adminjun
GMT时间转换
                                    
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 
1、可以使用 
SimpleDateFormat SimpleDateFormat    
EEE-三位星期 
d-天 
MMM-月 
yyyy-四位年 

    
                                
    • 
                                
  • Oracle数据库新装连接串问题
                                    aijuans
oracle数据库
                                    
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： 
Fatal NI connect error 12170. 
  VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
    
                                
    • 
                                
  • 回顾java数组复制
                                    ayaoxinchao
java数组
                                    
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
    
                                
    • 
                                
  • java web会话监听并使用spring注入
                                    bewithme
Java Web
                                    
      
      在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。 
       
import java.util.ArrayList;
import java.ut
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用)
                                    bijian1013
redis数据库NoSQL
                                    
    一 .Redis常用命令 
        Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。 
        a.键值相关命令 
        b.服务器相关命令 
1.键值相关命令 
      &
    
                                
    • 
                                
  • java枚举序列化问题
                                    bingyingao
java枚举序列化
                                    
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 
 
 
1.加一个枚举值 
新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 
 
老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 
 
 
 
  2.删一个枚举值 
新机器代码读分布式缓存中老对象，反序列
    
                                
    • 
                                
  • 【Spark七十八】Spark Kyro序列化
                                    bit1129
spark
                                    
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 
 
 Spark
    
                                
    • 
                                
  • Hybridizing OO and Functional Design
                                    bookjovi
erlanghaskell
                                    
      推荐博文：
Tell Above, and Ask Below - Hybridizing OO and Functional Design  
文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-HashMap
                                    BrokenDreams
Collections
                                    
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。 
 &nb
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 
 




/**
 * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请
 * bylijinnan
 */
abstract class Handler {
	/* 
    
                                
    • 
                                
  • Android中启动外部程序
                                    cherishLC
android
                                    
    1、启动外部程序 
引用自： 
http://blog.csdn.net/linxcool/article/details/7692374 
 
//方法一
Intent intent=new Intent();
//包名 包名+类名（全路径）
intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
    
                                
    • 
                                
  • summary_keep_rate
                                    coollyj
SUM
                                    
    
BEGIN  
      /*DECLARE  minDate varchar(20) ;
      DECLARE  maxDate varchar(20) ;*/
      DECLARE  stkDate varchar(20) ;

      DECLARE done int default -1; 
			/* 游标中 注册服务器地址 */  
      DE
    
                                
    • 
                                
  • hadoop hdfs 添加数据目录出错
                                    daizj
hadoophdfs扩容
                                    
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 
 
2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
    
                                
    • 
                                
  • grep 目录级联查找
                                    dongwei_6688
grep
                                    
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： 
grep -n -r "GET" . 
  
上面的命令将会找出当前目录“.”及当前目录中所有下级目录
    
                                
    • 
                                
  • yii 修改模块使用的布局文件
                                    dcj3sjt126com
yiilayouts
                                    
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如:  'theme'=>'mythm',   那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件；   如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
    
                                
    • 
                                
  • 设计模式之单例模式
                                    come_for_dream
设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                                    
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。 
  
*********************************
    
                                
    • 
                                
  • 8、数组
                                    豆豆咖啡
二维数组数组一维数组
                                    
      
一、概念 
  
    数组是同一种类型数据的集合。其实数组就是一个容器。 
  
二、好处 
  
    可以自动给数组中的元素从0开始编号，方便操作这些元素 
  
三、格式 
  
//一维数组
1,元素类型[] 变量名 = new 元素类型[元素的个数]
int[] arr =
    
                                
    • 
                                
  • Decode Ways
                                    hcx2013
decode
                                    
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 
'A' -> 1
'B' -> 2
...
'Z' -> 26
 
Given an encoded message containing digits, det
    
                                
    • 
                                
  • Spring4.1新特性——异步调度和事件机制的异常处理
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • squid3(高命中率)缓存服务器配置
                                    liyonghui160com

                                    
      
  
系统:centos 5.x 
  需要的软件:squid-3.0.STABLE25.tar.gz 
1.下载squid 
wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz 
tar zxf squid-3.0.STABLE25.tar.gz &&
    
                                
    • 
                                
  • 避免Java应用中NullPointerException的技巧和最佳实践
                                    pda158
java
                                    
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。   　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 
Object unk
    
                                
    • 
                                
  • 如何在Swift语言中创建http请求
                                    shoothao
httpswift
                                    
      
 概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。  
   
如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 
在这里,我将作出一些建议来回答上述问题。常见的
    
                                
    • 
                                
  • Spring事务的传播方式
                                    uule
spring事务
                                    
    传播方式：  
      新建事务 
      required 
      required_new   - 挂起当前 
  
      非事务方式运行 
      supports 
  &nbs
    
                                
    •