innovatorCL
innovatorCL

Rxjava2.1 线程切换原理解析

一、前提说明

本文是在 Rxjava 2.1 的基础上进行的，目前只对 Rxjava 进行解析，未搭配 Retrofit 食用，如果想看 Rxjava + Retrofit 源码解析，请移步 Retrofit 2.1 + Rxjava 源码解析（一）。

二、Rxjava 使用栗子

new Thread("子线程"){
          @Override
          public void run() {
              Observable.create(new ObservableOnSubscribe() {
                          @Override
                          public void subscribe(ObservableEmitter emitter) throws Exception {
                              Log.e(TAG, "Observable#subscribe(): 所在线程为 " + Thread.currentThread().getName());
                              emitter.onNext("1");
                              emitter.onComplete();
                          }
                      })
//              .subscribeOn(Schedulers.io())
                      .observeOn(Schedulers.io())
                      .subscribe(new Observer() {
                          @Override
                          public void onSubscribe(Disposable d) {
                              Log.e(TAG, "observer#onSubscribe(): 所在线程为 " + Thread.currentThread().getName());
                          }

                          @Override
                          public void onNext(String s) {
                              Log.e(TAG, "observer#onNext(): 所在线程为 " + Thread.currentThread().getName());
                          }

                          @Override
                          public void onError(Throwable e) {
                          }

                          @Override
                          public void onComplete() {
                              Log.e(TAG, "observer#onComplete(): 所在线程为 " + Thread.currentThread().getName());
                          }
                      });
          }
      }.start();

输出结果：

E/Rxjava: observer#onSubscribe(): 所在线程为 子线程
E/Rxjava: Observable#subscribe(): 所在线程为 子线程
E/Rxjava: observer#onNext(): 所在线程为 RxCachedThreadScheduler-1
E/Rxjava: observer#onComplete(): 所在线程为 RxCachedThreadScheduler-1

在 Rxjava2.1订阅流程解析 中我们已经分析了 Observable.create() 的过程，就是构建一个 ObservableCreate 对象，ObservableCreate 是 Observable 的子类。

由上文可以知道，当调用了 subscribe() 后，会执行以下顺序：Observable.subscribe(Observer) -> ObservableCreate.subscribeActual(Observer) -> Observer#onSubscribe()，所以可以知道 Observer#onSubscribe() 的执行线程是当前线程，即调用了 subscribe()的线程。

三、Observable.observeOn(Schedulers.io())

从上面栗子可以看到，如果我们只是调用了 observeOn(Schedulers.io())，这样影响的是 observer 的 onNext() 和 onComplete()，对于 ObservableOnSubscribe#subscribe() 和 Observer#onSubscribe() 是没有影响的。

我们看看 Observable.observeOn(Schedulers.io()) 的源码：

public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        //删除无关紧要的代码
        //这里的 this 是 ObservableCreate 对象
        return new ObservableObserveOn(this, scheduler, delayError, bufferSize);
    }

可以看到就是将传入的 ObservableCreate 对象封装进了 ObservableObserveOn 对象中，可以肯定的是 ObservableObserveOn 也是 Observable 的子类。

我们从上文得知，接下来会调用 observable.subscribe(observer) 的时候会跳转调用 Observable 子类的 ObservableObserveOn.subscribeActual(observer) 方法。这其实是用了静态工厂模式。

public final class ObservableObserveOn extends AbstractObservableWithUpstream {

    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(Observer observer) {
         // 如果传入的 scheduler 是 Scheduler.trampoline() 的情况
        // 该线程的意义是传入当前线程，也就是不做任何线程切换操作
        if (scheduler instanceof TrampolineScheduler) {
            source.subscribe(observer);
        } else {
            Scheduler.Worker w = scheduler.createWorker();
            //这里的 source 是 ObservableCreate 对象
            source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
        }
    }
}

当需要切换线程的时候，可以看到将传进来的 ObservableCreate 对象进行了订阅，只不过观察者又被封装成了 ObserveOnObserver 对象。这样就会执行 ObservableCreate#subscribeActual()。

public final class ObservableCreate extends Observable {
    final ObservableOnSubscribe source;

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

    @Override
    protected void subscribeActual(Observer observer) {
        //这里的 observer 就是 ObserveOnObserver 对象
        CreateEmitter parent = new CreateEmitter(observer);
        //这里的 observer 就是 ObserveOnObserver 对象
        observer.onSubscribe(parent);

        try {
            //这里的额 source 就是我们在最外层创建的 ObservableOnSubscribe 对象
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
}

这里可以看到使用了 observeOn(Schedulers.io()) 方法，但是 Observer#onSubscribe(Disposable d) 并没有切换线程，仍在当前线程中运行。也就是 ObserveOnObserver.onSubscribe() 是运行在当前线程的。我们看看这个方法做了什么：

static final class ObserveOnObserver extends BasicIntQueueDisposable implements Observer, Runnable {

        private static final long serialVersionUID = 6576896619930983584L;
        //真正的观察者，最外层我们创建的 observer
        final Observer actual;
        final Scheduler.Worker worker;

        Disposable s;

        ......
        
        ObserveOnObserver(Observer actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.actual = actual;
            this.worker = worker;
        }

        @Override
        public void onSubscribe(Disposable s) {
            if (DisposableHelper.validate(this.s, s)) {
                this.s = s;
                if (s instanceof QueueDisposable) {
                    @SuppressWarnings("unchecked")
                    QueueDisposable qd = (QueueDisposable) s;

                    int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);

                    if (m == QueueDisposable.SYNC) {
                        sourceMode = m;
                        queue = qd;
                        done = true;
                        //执行真正的被观察者 Observer（最外层我们创建的 observer）#onSubscribe()
                        actual.onSubscribe(this);
                        schedule();
                        return;
                    }
                    if (m == QueueDisposable.ASYNC) {
                        sourceMode = m;
                        queue = qd;
                        //执行真正的被观察者 Observer（最外层我们创建的 observer）#onSubscribe()
                        actual.onSubscribe(this);
                        return;
                    }
                }

                queue = new SpscLinkedArrayQueue(bufferSize);
                //执行真正的被观察者 Observer（最外层我们创建的 observer）#onSubscribe()
                actual.onSubscribe(this);
            }
        }

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

            if (sourceMode != QueueDisposable.ASYNC) {
                queue.offer(t);
            }
            schedule();
        }

        @Override
        public void onError(Throwable t) {
            if (done) {
                RxJavaPlugins.onError(t);
                return;
            }
            error = t;
            done = true;
            schedule();
        }

        @Override
        public void onComplete() {
            if (done) {
                return;
            }
            done = true;
            schedule();
        }

        @Override
        public void dispose() {
            if (!cancelled) {
                cancelled = true;
                s.dispose();
                worker.dispose();
                if (getAndIncrement() == 0) {
                    queue.clear();
                }
            }
        }
    
    void schedule() {
            if (getAndIncrement() == 0) {
                //this 就是 ObserveOnObserver 对象
                worker.schedule(this);
            }
        }
}

可以看到 ObserveOnObserver#onSubscribe(Disposable s) 中一定会调用 actual.onSubscribe(this);，其中这个 this 就是 ObserveOnObserver 对象，也就是让我们最外层的 observer 订阅了 ObserveOnObserver。

可以看到在 RxJava 中运用的操作符都会在内部创建一个 Observable 和 Observer，所以外界使用起来和简单，但是里面运行的原理倒是挺复杂的，容易让人混淆。

运行完 ObserveOnObserver#onSubscribe(Disposable s) 后，就轮到了 source.subscribe(parent);(这里的额 source 就是我们在最外层创建的 ObservableOnSubscribe 对象)，也就是说我们的 ObservableOnSubscribe#subscribe(emitter) 运行在当前线程。到这里的分析都很符合我们打印的结果。

而我们在最外层，只是让发射器 emitter 简单地发送了一个 Next 事件。这个事件会被谁接收呢？

static final class CreateEmitter extends AtomicReference
    implements ObservableEmitter, Disposable {
    
        private static final long serialVersionUID = -3434801548987643227L;

        final Observer observer;

        CreateEmitter(Observer observer) {
            //这里的 observer 就是 ObserveOnObserver 对象
            this.observer = observer;
        }

        @Override
        public void onNext(T t) {
            //这里的 observer 就是 ObserveOnObserver 对象
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }
        
        ......
}

我们从之前调用到 ObservableCreate#subscribeActual() 可以知道，当时传进来的 parent 是 ObserveOnObserver 对象。所以发射器 emitter 发射的事件会被 ObserveOnObserver 接收。

可以看到 ObserveOnObserver.onNext() 中最后执行了 schedule()，也就是在这里进行了线程切换的操作。

由于我们传入的 Scheduler 是 IO 线程，我们看看这个 IO Schedule 的 worker.schedule(this)。

一路追踪，终于找到了这个 IOScheduler 的庐山真面目：

public final class IoScheduler extends Scheduler {

private static final String WORKER_THREAD_NAME_PREFIX = "RxCachedThreadScheduler";
    static final RxThreadFactory WORKER_THREAD_FACTORY;

    private static final String EVICTOR_THREAD_NAME_PREFIX = "RxCachedWorkerPoolEvictor";
    static final RxThreadFactory EVICTOR_THREAD_FACTORY;

    private static final long KEEP_ALIVE_TIME = 60;
    private static final TimeUnit KEEP_ALIVE_UNIT = TimeUnit.SECONDS;

    static final ThreadWorker SHUTDOWN_THREAD_WORKER;
    final ThreadFactory threadFactory;
    final AtomicReference pool;
    
    public Worker createWorker() {
        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();
            this.threadWorker = pool.get();
        }

        @Override
        public void dispose() {
            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);
        }
    }

    ......
}

至此，你可以看到调用了 observerOn() 方法的全过程，只是会改变观察者 observer 的 onNext()、onComplete() 方法的运行线程，不会改变被观察者 Observable 的运行线程。

四、observeOn() 切换线程原理小结

看完整个过程，我们知道当我们使用 observeOn(Schedulers.io())的时候，其实 Rxjava 在内部帮我们创建封装了若干个中间对象的 Observable 和 Observer。然后将这个订阅操作放在 Rxjava 的线程池进行，达到切换线程的功能。

被观察者 Observable 的变化过程：Observable ==> ObservableCreate ==> ObserbvableObserveOn。

观察者 Observer 的变化过程：Observer ==> ObserveOnObserver，然后传到 ObservableEmitter emitter 里面，作为发射器的 observer 成员变量。

总之，Observable#observeOn(Scheduler) 的实现原理在于将目标 Observer 的 onNext(T)/onError(Throwable)/onComplete() 置于指定线程中运行。

五、subscribeOn() 栗子

new Thread("子线程"){
          @Override
          public void run() {
              Observable
                      .create(new ObservableOnSubscribe() {
                          @Override
                          public void subscribe(ObservableEmitter emitter) throws Exception {
                              Log.e(TAG, "ObservableOnSubscribe#subscribe(): 所在线程为 " + Thread.currentThread().getName());
                              emitter.onNext("1");
                              emitter.onComplete();
                          }
                      })
                      .subscribeOn(Schedulers.io())
//                      .observeOn(Schedulers.io())
                      .subscribe(new Observer() {
                          @Override
                          public void onSubscribe(Disposable d) {
                              Log.e(TAG, "observer#onSubscribe(): 所在线程为 " + Thread.currentThread().getName());
                          }

                          @Override
                          public void onNext(String s) {
                              Log.e(TAG, "observer#onNext(): 所在线程为 " + Thread.currentThread().getName());
                          }

                          @Override
                          public void onError(Throwable e) {
                          }

                          @Override
                          public void onComplete() {
                              Log.e(TAG, "observer#onComplete(): 所在线程为 " + Thread.currentThread().getName());
                          }
                      });
          }
      }.start();

输出结果：

E/Rxjava: observer#onSubscribe(): 所在线程为 子线程
E/Rxjava: ObservableOnSubscribe#subscribe(): 所在线程为 RxCachedThreadScheduler-2
E/Rxjava: observer#onNext(): 所在线程为 RxCachedThreadScheduler-2
E/Rxjava: observer#onComplete(): 所在线程为 RxCachedThreadScheduler-2

六、ObservableCreate.subscribeOn()

由上文可以，Observable.create() 会生成一个 ObservableCreate 对象。我们看看 ObservableCreate.subscribeOn()。

public final Observable subscribeOn(Scheduler scheduler) {
        //过滤无关紧要的代码
        //this 是 ObservableCreate 对象
        return new ObservableSubscribeOn(this, scheduler);
    }

可以看到将 ObservableCreate 对象封装成了 ObservableSubscribeOn 对象，然后就会执行 ObservableSubscribeOn#subscribeActual()。

public final class ObservableSubscribeOn extends AbstractObservableWithUpstream {
    final Scheduler scheduler;

    //这里的 source 是 ObservableCreate 对象，scheduler 是 IoScheduler
    public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }

    @Override
    public void subscribeActual(final Observer s) {
        //s 是最外层的 observer
        final SubscribeOnObserver parent = new SubscribeOnObserver(s);
        
        //调用 observer#onSubscribe
        s.onSubscribe(parent);

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

可以看到 observer#onSubscribe() 仍在在当前线程中执行，之后的 observer 和 ObservableOnSubscribe 的方法都被线程切换类 IoScheduler 切换到了其他线程。

我们看看 IoScheduler 的 scheduler.scheduleDirect(new SubscribeTask(parent)))。

final class SubscribeTask implements Runnable {
        //这个 parent 就是 SubscribeOnObserver
        private final SubscribeOnObserver parent;

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

        @Override
        public void run() {
            //source 就是 ObservableCreate 对象
            //parent 就是 SubscribeOnObserver 对象
            source.subscribe(parent);
        }
    }
    
    static final class SubscribeOnObserver extends AtomicReference implements Observer, Disposable {

        private static final long serialVersionUID = 8094547886072529208L;
        final Observer actual;

        final AtomicReference s;

        SubscribeOnObserver(Observer actual) {
            //actual 就是最外层的 observer 
            this.actual = actual;
            this.s = new AtomicReference();
        }

        @Override
        public void onSubscribe(Disposable s) {
            DisposableHelper.setOnce(this.s, s);
        }

        @Override
        public void onNext(T t) {
            actual.onNext(t);
        }

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

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

        @Override
        public void dispose() {
            DisposableHelper.dispose(s);
            DisposableHelper.dispose(this);
        }
        
        @Override
        public boolean isDisposed() {
            return DisposableHelper.isDisposed(get());
        }

        void setDisposable(Disposable d) {
            DisposableHelper.setOnce(this, d);
        }
    }

可以看到将最外层的 observer 包装成 SubscribeOnObserver 对象，然后包装成一个 SubscribeTask（可以执行的任务）。当在线程池中被执行的时候，会执行 SubscribeTask#run()。

我们再看 IoSchedule#scheduleDirect(subscribeTask)。

在 IoSchedule 的父类 Schedule 中找到一个方法：

public abstract class Scheduler {
    public Disposable scheduleDirect(@NonNull Runnable run) {
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }
    
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        final Worker w = createWorker();

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        DisposeTask task = new DisposeTask(decoratedRun, w);
        //其实就是 EventLoopWorker#schedule()
        w.schedule(task, delay, unit);

        return task;
    }
}

又回到了 IOScheduler 创建的 EventLoopWorker 中：

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

        @Override
        public void dispose() {
            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);
        }
    }

static final class ThreadWorker extends NewThreadWorker {
        private long expirationTime;

        ThreadWorker(ThreadFactory threadFactory) {
            super(threadFactory);
            this.expirationTime = 0L;
        }

        public long getExpirationTime() {
            return expirationTime;
        }

        public void setExpirationTime(long expirationTime) {
            this.expirationTime = expirationTime;
        }
    }

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

    volatile boolean disposed;

    public NewThreadWorker(ThreadFactory threadFactory) {
        executor = SchedulerPoolFactory.create(threadFactory);
    }
    
    ......
    
    public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

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

        Future f;
        try {
            if (delayTime <= 0) {
                //放进线程池中执行
                f = executor.submit((Callable)sr);
            } else {
                //放进线程池中执行
                f = executor.schedule((Callable)sr, delayTime, unit);
            }
            sr.setFuture(f);
        } catch (RejectedExecutionException ex) {
            if (parent != null) {
                parent.remove(sr);
            }
            RxJavaPlugins.onError(ex);
        }

        return sr;
    }
    
    ......
}
 
 
最终在线程池中执行了我们的 SubscribeTask#run()。其实从 scheduleActual() 和 subscribeActual() 的命名方式可以看出，Rxjava 很多地方都用到了静态工厂模式，都是父类提供抽象方法，具体的子类根据需要实现不同的逻辑，这个就很灵活了。
 
 
我们再看看 SubscribeTask#run() 干了什么：
 
 
final class SubscribeTask implements Runnable {
        //这个 parent 就是 SubscribeOnObserver
        private final SubscribeOnObserver parent;

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

        @Override
        public void run() {
            //source 就是 ObservableCreate 对象
            //parent 就是 SubscribeOnObserver 对象
            source.subscribe(parent);
        }
    }

 
 
**那其实就是 ObservableCreate.subscribe(SubscribeOnObserver)，这就又跳到了我们熟悉的 ObservableCreate.subscribeActual() 方法中了。
 
 
public final class ObservableCreate extends Observable {
    final ObservableOnSubscribe source;

    //source 是最外层的 ObservableOnSubscribe 对象
    public ObservableCreate(ObservableOnSubscribe source) {
        this.source = source;
    }

    @Override
    protected void subscribeActual(Observer observer) {
        //observer 是 SubscribeOnObserver 对象，里面包含最外层的 observer 对象
        CreateEmitter parent = new CreateEmitter(observer);
        //这里 SubscribeOnObserver 只是简单地 set 了一个引用
        observer.onSubscribe(parent);

        try {
            //其实就是 ObservableOnSubscribe.subscribe(SubscribeOnObserver);
            //此时已经运行在 Rxjava 的线程池中
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
    
    ......
}

 
 
在这里会先执行 observer （SubscribeOnObserver）的 onSubscribe() 方法，这个方法就 set 了一个引用，可以先忽略。接下来会调用 ObservableOnSubscribe.subscribe(SubscribeOnObserver)。
 
 
Observable.create(new ObservableOnSubscribe() {
                          @Override
                          public void subscribe(ObservableEmitter emitter) throws Exception {
                              Log.e(TAG, "ObservableOnSubscribe#subscribe(): 所在线程为 " + Thread.currentThread().getName());
                              emitter.onNext("1");
                              emitter.onComplete();
                          }
                      });

 
 
我们在最外层只发送了一个 Next 事件，根据 CreateEmitter 类的源码：
 
 
public void onNext(T t) {
           
            if (!isDisposed()) {
                //observer 就是 SubscribeOnObserver 
                observer.onNext(t);
            }
        }

 
 
SubscribeOnObserver.onNext() 会触发：
 
 
static final class SubscribeOnObserver extends AtomicReference implements Observer, Disposable {

        private static final long serialVersionUID = 8094547886072529208L;
        final Observer actual;

        final AtomicReference s;

        SubscribeOnObserver(Observer actual) {
            //最外层的 observer 
            this.actual = actual;
            this.s = new AtomicReference();
        }

        @Override
        public void onSubscribe(Disposable s) {
            DisposableHelper.setOnce(this.s, s);
        }

        @Override
        public void onNext(T t) {
            //调用最外层的 observer#onNext()
            actual.onNext(t);
        }

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

        @Override
        public void onComplete() {
            //调用最外层的 observer#onComplete()
            actual.onComplete();
        }

        @Override
        public void dispose() {
            DisposableHelper.dispose(s);
            DisposableHelper.dispose(this);
        }

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

        void setDisposable(Disposable d) {
            DisposableHelper.setOnce(this, d);
        }
    }

 
 
所以，我们最外层的 observer 的 onNext() 和 onComplete() 会运行在 Rxjava 的线程池的线程中。
 
 
至此，subscribeOn(Schedulers.io()) 的过程分析完毕，subscribeOn(Schedulers.io()) 会改变观察者 observer 的 onNext()、onComplete() 方法的运行线程，也会改变被观察者 Observable 的运行线程。
 
 
七、subscribeOn() 切换线程原理小结
 
 
看完整个过程，我们知道当我们使用 subscribeOn(Schedulers.io())的时候，其实跟上面的 observeOn(Schedulers.io()) 过程差不多，Rxjava 帮我们创建了若干个中间层的 Observable 和 Observer，然后将这个订阅操作放在 Rxjava 的线程池进行，达到切换线程的功能。
 
 
被观察者 Observable 的变化过程：Observable ==> ObservableCreate ==> ObserbvableSubscribeOn。
 
 
观察者 Observer 的变化过程：Observer ==> SubscribeOnObserver，然后传到 ObservableEmitter emitter 里面，作为发射器的 observer 成员变量。
 
 
总之，Observable#subscribeOn(Scheduler) 的实现原理在于将目标 Observer 的 onNext(T)/onError(Throwable)/onComplete() 和 ObservableOnSubscribe 的 subscribe(T) 置于指定线程中运行。
 
 
八、subscribeOn() 和 observeOn(Schedulers.io()) 一起使用
 
 
这两个 api 一起使用其实也不会有什么很大的变化，就是 observeOn() 会影响 Observer 的 onNext(T)/onError(Throwable)/onComplete() 运行线程，而 subscribeOn() 会影响 ObservableOnSubscribe 的 subscribe(T) 运行线程。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Rxjava2.1 线程切换原理解析)

        

            

                
    
                    
  • SQL Server_查询某一数据库中的所有表的内容
                        qq_42772833
SQLServer数据库sqlserver
                        
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
    
                    
    • 
                    
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
                        nseejrukjhad
langchaineasyui前端python
                        
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
    
                    
    • 
                    
  • 01-Git初识
                        Meereen
Gitgit
                        
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    
                    
    • 
                    
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
                        GPJnCrbBdl
python开发语言
                        
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • ios GCD
                        _Waiting_

                        
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
    
                    
    • 
                    
  • 多线程之——ExecutorCompletionService
                        阿福德

                        
    在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
    
                    
    • 
                    
  • python多线程程序设计 之一
                        IT_Beijing_BIT
#Python程序设计语言python
                        
    python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
    
                    
    • 
                    
  • Python神器！WEB自动化测试集成工具 DrissionPage
                        亚丁号
python开发语言
                        
    一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • Python多线程实现大规模数据集高效转移
                        sand&wich
网络python服务器
                        
    背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
    
                    
    • 
                    
  • Python实现下载当前年份的谷歌影像
                        sand&wich
python开发语言
                        
    在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • vue+el-table 可输入表格使用上下键进行input框切换
                        以对_
vue学习记录vue.jsjavascript前端
                        
    使用上下键进行完工数量这一列的切换-->//键盘触发事件show(ev,index){letnewIndex;letinputAll=document.querySelectorAll('.table_inputinput');//向上=38if(ev.keyCode==38){if(index==0){//如果是第一行,回到最后一个newIndex=inputAll.length-1}elsei
    
                    
    • 
                    
  • 经纬恒润二面&三七互娱一面&元象二面
                        Redstone Monstrosity
面试前端
                        
    1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换
                        让开，我要吃人了
OpenHarmonyHarmonyOS鸿蒙开发harmonyos华为鸿蒙移动开发鸿蒙系统前端开发语言
                        
    鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
    
                    
    • 
                    
  • Redis Key的过期策略
                        ArchManual
分布式架构分布式Java后端微服务架构redis
                        
    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
    
                    
    • 
                    
  • Redis:缓存击穿
                        我的程序快快跑啊
缓存redisjava
                        
    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
    
                    
    • 
                    
  • ffmpeg批量将tif文件转成jpeg格式
                        winfredzhang
图像工具ffmpegtifjpeg转换
                        
    1、cmd2、切换到安装ffmpeg的路径。3、输入命令：ffmpeg-start_number001-i"D:\ocr\%03d.tif"-start_number001-pix_fmtyuv420p-qscale:v1"D:\ocr\%03d.jpg"结果。
    
                    
    • 
                    
  • vue2实现复制,粘贴功能
                        周bro
vue.jsjavascript前端
                        
    一、需求说明在项目中点击按钮复制某行文本是很常见的应用场景，在Vue项目中实现复制功能需要借助vue-clipboard2插件。二、代码实现1、安装vue-clipboard2依赖（出现错误的话，可以试试切换成淘宝镜像源npmconfigsetregistryhttps://registry.npm.taobao.org）npminstall--savevue-clipboard22、在main.
    
                    
    • 
                    
  • 【java】怎么理解不同对象实例的对象锁是互不干扰的
                        晨春计
Androidjava
                        
    在Java中，synchronized关键字用于实现线程同步，它可以作用于实例方法、静态方法以及代码块。当synchronized应用于实例方法或实例变量时，它创建的是一个对象锁，这个锁是与特定的对象实例关联的。因此，每个对象实例都有其自己的锁。这里的关键点在于，对象锁是绑定到特定对象实例上的。这意味着对于不同的对象实例，即使它们属于同一个类，它们各自拥有独立的对象锁。当一个线程获取了一个对象实例
    
                    
    • 
                    
  • 程序计数器的作用
                        毕加涛
java
                        
    程序计数器的作用就是**用来记住下一条jvm指令的执行地址。**它的特点是**线程私有的**，也就是一人一个。然后cpu会给每个线程分配时间片，然后等待这个线程的时间片用完之后就会轮到下一个线程来执行。所以此时就需要计数器来记录线程运行的下一行指令的地址，等到下次轮到这个线程执行的时候来到上次执行的指令地址来继续执行指令。所以它的作用就是：为了保证程序的执行遵循自上而下有顺序的执行。
    
                    
    • 
                    
  • tcp线程进程多并发
                        @莫福瑞
算法
                        
    tcp线程多并发#include#defineSERPORT8888#defineSERIP"192.168.0.118"#defineBACKLOG20typedefstruct{intnewfd;structsockaddr_incin;}BMH;void*fun1(void*sss){intnewfd=accept((BMH*)sss)->newfd;structsockaddr_incin
    
                    
    • 
                    
  • 15-自编写rtos-结合stm32实际调试(ladylolo-os)
                        Ladylolo-lsm
stm32嵌入式硬件单片机
                        
    一、任务调度:1.理解:任务切换，用堆栈指针SP保存即将要切换的任务的前后文，然后是用PendSV来执行这些操作的；由于是基于优先级的调度策略，所以每次“心跳”都会看有没有优先级更高的出现，如果有就用PendSV进行上下文切换。2.编写部分:①每个任务自己的属性统称为TCB任务控制块。②任务就绪表有设置优先级(设置的时候变量或上优先级的变量让某个位数等于1)，从任务就绪表中删除(删除时用与来得等于
    
                    
    • 
                    
  • 保证RTOS线程安全的常规操作
                        WittXie
单片机嵌入式硬件
                        
    线程安全定义原子操作：一种不可分割的操作，要么完全执行成功，要么完全不执行，不能被打断临界区：一段代码，这段代码需要在同一时间只允许一个线程执行互斥锁：一种用于保护共享资源的机制，确保同一时间只有一个线程可以访问特定资源应用裸机原子操作/临界区可以通过暂时关闭中断响应实现一般用不到互斥锁RTOS原子操作：暂时关闭中断响应+挂起所有应用（不建议，RTOS尽量不要开启中断，改为线程监听）临界区：挂起所
    
                    
    • 
                    
  • 单线程执行器（`SingleThreadedExecutor`）来处理节点的任务
                        课堂随想
moveit2机器人
                        
    intmain(intargc,char**argv){rclcpp::init(argc,argv);rclcpp::NodeOptionsnode_options;node_options.automatically_declare_parameters_from_overrides(true);automove_group_node=rclcpp::Node::make_shared("mo
    
                    
    • 
                    
  • golang学习笔记--MPG模型
                        xxzed
golang#学习笔记学习笔记golang
                        
    MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
    
                    
    • 
                    
  • C# 开发教程-入门基础
                        天马3798
教程系列整理c#开发语言
                        
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
    
                    
    • 
                    
  • 【C#Mutex】 initiallyOwned错误引起的缺陷
                        闻缺陷则喜何志丹
c#互斥量进程同步WaitOneinitiallyOwned临界区
                        
    临界区只能对同一个进程的不同线程同步，互斥量可以跨进程同步。典型应用场景：两个exe会操作同一个注册表项。错误代码封装类publicclassCMutexHelp:IDisposable{publicCMutexHelp(){s_mutex.WaitOne();}privatestaticMutexs_mutex=newMutex(true,"Time202409091406ab");public
    
                    
    • 
                                
  • [黑洞与暗粒子]没有光的世界
                                    comsci

                                    
         无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算 
 
     但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界.... 
 
     那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的 
 
&nbs
    
                                
    • 
                                
  • jQuery Lazy Load 图片延迟加载
                                    aijuans
jquery
                                    
    基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。 
对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。 
 
 版本： 
 

  jQuery v1.4.4+ 
 

  jQuery Lazy Load v1.7.2 
 
 
 注意事项： 
 
 
 需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
    
                                
    • 
                                
  • 使用Jodd的优点
                                    Kai_Ge
jodd
                                    
    1.  简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。 
2.  简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。 
3.  对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。 
  
使用方法简介
    
                                
    • 
                                
  • jpa Query转hibernate Query
                                    120153216
Hibernate
                                    
    public List<Map> getMapList(String hql,
			Map map) {
		org.hibernate.Query jpaQuery = entityManager.createQuery(hql);
		if (null != map) {
			for (String parameter : map.keySet()) {
				jp
    
                                
    • 
                                
  • Django_Python3添加MySQL/MariaDB支持
                                    2002wmj
mariaDB
                                    
    现状 
首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案 
首先据MySQL文档[3]说，自从MySQL
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗IO最多的SQL
                                    357029540
SQL Server
                                    
    返回做IO数目最多的50条语句以及它们的执行计划。 
select top 50   
 
(total_logical_reads/execution_count) as avg_logical_reads,  
 
(total_logical_writes/execution_count) as avg_logical_writes,  
 
(tot
    
                                
    • 
                                
  • spring UnChecked 异常 官方定义！
                                    7454103
spring
                                    
      如果你接触过spring的 事物管理！那么你必须明白 spring的 非捕获异常！ 即 unchecked 异常！ 因为 spring 默认这类异常事物自动回滚！！ 
 
 
 
 
public static boolean isCheckedException(Throwable ex)
    {
   return !(ex instanceof RuntimeExcep
    
                                
    • 
                                
  • mongoDB 入门指南、示例
                                    adminjun
javamongodb操作
                                    
    一、准备工作 
1、 下载mongoDB 
下载地址：http://www.mongodb.org/downloads 
选择合适你的版本 
相关文档：http://www.mongodb.org/display/DOCS/Tutorial 
2、 安装mongoDB 
A、 不解压模式： 
将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
    
                                
    • 
                                
  • CUDA 5 Release Candidate Now Available
                                    aijuans
CUDA
                                    
    The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
    
                                
    • 
                                
  • Essential Studio for WinRT网格控件测评
                                    Axiba
JavaScripthtml5
                                    
    Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。 
 
 
网格控件功能 
1、
    
                                
    • 
                                
  • java 获取windows系统安装的证书或证书链
                                    bewithme
windows
                                    
      
    有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库  。 
有关证书链的解释可以查看此处 。 
  
public static void main(String[] args) {
		SunMSCAPI providerMSCAPI = new SunMSCAPI();
		S
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(set类型和zset类型)
                                    bijian1013
redis数据库NoSQL
                                    
    4.sets类型 
        Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。 
        sadd：向名称为key的set中添加元
    
                                
    • 
                                
  • 异常捕获何时用Exception，何时用Throwable
                                    bingyingao

                                    
    用Exception的情况 
 try { 
       //可能发生空指针、数组溢出等异常 
        } catch (Exception e) { 
         
    
                                
    • 
                                
  • 【Kafka四】Kakfa伪分布式安装
                                    bit1129
kafka
                                    
    在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证   1. 安装步骤 
  
Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
    
                                
    • 
                                
  • Project Euler
                                    bookjovi
haskell
                                    
    Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。 
    看看problem 1吧： 
 Add all the natural num
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-ArrayDeque
                                    BrokenDreams
Collections
                                    
            表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。 
        这篇要看一下java.util.ArrayDeque。从命名上看
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-装饰模式-Decorator
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.Fi
    
                                
    • 
                                
  • Maven学习(一)
                                    chenyu19891124
Maven私服
                                    
        学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
    
                                
    • 
                                
  • [原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充
                                    comsci
算法工作PHP搜索引擎嵌入式
                                    
    本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点 
 
 节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法) 
 
 需要解决的问题：已知分支
    
                                
    • 
                                
  • Linux中用shell获取昨天、明天或多天前的日期
                                    daizj
linuxshell上几年昨天获取上几个月
                                    
    在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年 
 
 
# 获取昨天 
date -d 'yesterday'  # 或 date -d 'last day' 
# 获取明天 
date -d 'tomorrow'   # 或 date -d 'next day' 
# 获取上个月 
date -d 'last month' 
# 
    
                                
    • 
                                
  • 我所理解的云计算
                                    dongwei_6688
云计算
                                    
          在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说： 
 
        Cloud computing is a phrase used to describe a variety of computing co
    
                                
    • 
                                
  • YII CMenu配置
                                    dcj3sjt126com
yii
                                    
    Adding id and class names to CMenu 
We use the id and htmlOptions to accomplish this. Watch.   
//in your view
$this->widget('zii.widgets.CMenu', array(
	'id'=>'myMenu',
	'items'=>$this-&g
    
                                
    • 
                                
  • 设计模式之静态代理与动态代理
                                    come_for_dream
设计模式
                                    
    静态代理与动态代理 
        代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
    
                                
    • 
                                
  • 【转】理解Javascript 系列
                                    gcc2ge
JavaScript
                                    
    理解Javascript_13_执行模型详解 
 
  摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
    
                                
    • 
                                
  • Subsets II
                                    hcx2013
set
                                    
    Given a collection of integers that might contain duplicates, nums, return all possible subsets. 
Note: 
 
 Elements in a subset must be in non-descending order. 
 The solution set must not conta
    
                                
    • 
                                
  • Spring4.1新特性——Spring缓存框架增强
                                    jinnianshilongnian
spring4
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • shell嵌套expect执行命令
                                    liyonghui160com

                                    
      
  
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧. 
  系统:centos 5.x 
  
1.先安装expect 
yum -y install expect 
  
2.脚本内容: 
cat auto_svn.sh 
  
#!/bin/bash

    
                                
    • 
                                
  • Linux实用命令整理
                                    pda158
linux
                                    
    0. 基本命令   　　linux 基本命令整理   　 
　1. 压缩 解压   　　tar -zcvf a.tar.gz a   #把a压缩成a.tar.gz   　　tar -zxvf a.tar.gz     #把a.tar.gz解压成a   　 
　2. vim小结   　　2.1 vim替换   　　:m,ns/word_1/word_2/gc  
    
                                
    • 
                                
  • 独立开发人员通向成功的29个小贴士
                                    shoothao
独立开发
                                    
      
 概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。  
   
 
 明白你从事独立开发的原因和目的。 
 保持坚持制定计划的好习惯。 
 万事开头难，第一份订单是关键。 
 培养多元化业务技能。 
 提供卓越的服务和品质。 
 谨小慎微。 
 营销是必备技能。 
 学会组织，有条理的工作才是最有效率的。 
 “独立
    
                                
    • 
                                
  • JAVA中堆栈和内存分配原理
                                    uule
java
                                    
    1、栈、堆  
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f
    
                                
    •