zYoung_Tang
zYoung_Tang

RxJava 2.x 源码分析(三)之一步一步了解切换线程原理

前文

Android 开发离不开异步操作，比如网络请求必须在子线程中进行，获取数据后可能需要更改UI，但是UI只能在主线程中被修改，所以我们经常在子线程和主线程中切换，代码就会比较繁琐不方便阅读。RxJava 的诞生是为了更好的处理异步操作，前面两篇文章我们了解到 RxJava 使用了观察者模式，现在继续了解 RxJava 利用观察者模式同时实现了线程切换。

线程调度

RxJava 中线程调度的核心方法是subscribeOn()和observeOn()

  • subscribeOn 控制被观察者发送事件所在的线程。
  • observeOn 观察者接收事件时的线程。

在查看源码之前可以先从下面几个例子中看效果

下面的例子都使用的是相同的被观察者和观察者:

  • 不切线程
  • 切换线程，被观察者发射事件操作切换到IO线程中执行，观察者接收事件切换到应用主线程中执行
  • 切换线程，与例2相同，增加调用 FlatMap 操作符

创建被观察者和观察者

// 创建被观察者
Observable observable = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        Log.d("RXJAVA_LOG", "发射事件1 -- " + Thread.currentThread().getName());
        e.onNext("item 1");
        Log.d("RXJAVA_LOG", "发射事件2 -- " + Thread.currentThread().getName());
        e.onNext("item 2");
        Log.d("RXJAVA_LOG", "发射事件3 -- " + Thread.currentThread().getName());
        e.onNext("item 3");
        Log.d("RXJAVA_LOG", "发射事件4 -- " + Thread.currentThread().getName());
        e.onNext("item 4");
    }
});

// 创建观察者
Observer observer = new Observer() {

    @Override
    public void onSubscribe(Disposable d) {
    }

    @Override
    public void onNext(String s) {
        Log.d("RXJAVA_LOG", "接受事件 : " + s + " -- " + Thread.currentThread().getName());
    }

    @Override
    public void onError(Throwable e) {
    }

    @Override
    public void onComplete() {
    }
};

例子1:不切线程

observable.subscribe(observer);

输出：

发射 item1     -- main
接受 item1 -- main
发射 item2     -- main
接受 item2 -- main
发射 item3     -- main
接受 item3 -- main
发射 item4     -- main
接受 item4 -- main

例子2:切换线程

 observable
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(observer);

输出：

发射 item1     -- RxCachedThreadScheduler-1
发射 item2     -- RxCachedThreadScheduler-1
发射 item3     -- RxCachedThreadScheduler-1
发射 item4     -- RxCachedThreadScheduler-1
接受 item1 -- main
接受 item2 -- main
接受 item3 -- main
接受 item4 -- main

例子3:使用FlatMap并切换线程

observable
    .flatMap(new Function>() {
        @Override
        public ObservableSource apply(String s) throws Exception {
            final String str = s;
            return Observable.create(new ObservableOnSubscribe() {
                @Override
                public void subscribe(ObservableEmitter e) throws Exception {
                    Log.d("RXJAVA_LOG", "发射 " + str + "-sub -- " + Thread.currentThread().getName());
                    e.onNext(str + "-sub");
                }
            });
        }
    })
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(observer);

输出:

发射 item1     -- RxCachedThreadScheduler-1
发射 item1-sub -- RxCachedThreadScheduler-1
发射 item2     -- RxCachedThreadScheduler-1
发射 item2-sub -- RxCachedThreadScheduler-1
发射 item3     -- RxCachedThreadScheduler-1
发射 item3-sub -- RxCachedThreadScheduler-1
接受 item1-sub -- main
发射 item4     -- RxCachedThreadScheduler-1
发射 item4-sub -- RxCachedThreadScheduler-1
接受 item2-sub -- main
接受 item3-sub -- main
接受 item4-sub -- main

从上面的例子可以看出:

  • subscribeOn()可以切换被观察者和使用FlatMap或者其他操作符的子被观察者发射的事件的线程。
  • observeOn()可以控制观察者接收事件所在的线程。

那么我们就可以把网络请求操作作为被观察者的事件，并且把发送事件线程切换到IO线程，然后把更新UI操作放到观察者接收事件的回调中，并把接收事件所在线程切换回主线程，这样就可以利用 RxJava 完成我们网络请求的异步操作。

以例子2为阅读源码的例子，根据subscribeOn()、observeOn()、subscribe()的调用顺序分为三步查看

1. subscribeOn()

下面我们开始阅读源码，先从subscribeOn(Schedulers.io())开始看，首先看看io()方法

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

这里出现了一个变量IO，看看是什么东西

// Schedulers.java
public final class Schedulers {
    @NonNull
    static final Scheduler IO;
    
    static {    
        IO = RxJavaPlugins.initIoScheduler(new IOTask());
        ...
    }
    ...
}

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

原来变量IO是一个Scheduler对象且是Schedulers的静态成员变量且在类加载的时候已经初始化了，PS：Schedulers可以看成是一个用来创建Scheduler的工厂，提供多个静态方法如io()、newThread()、computation等来获取适用于不同场景的Scheduler。

接着看初始化过程，首先创建了一个IOTask实例，然后传给RxJavaPlugins的初始化方法initIoScheduler()

// RxJavaPlugins.java
@NonNull
public static Scheduler initIoScheduler(@NonNull Callable defaultScheduler) {
    // 检查 IOTask 是否为空
    ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");
    Function, ? extends Scheduler> f = onInitIoHandler;
    if (f == null) { // onInitIoHandler 没有被设置，所以为 null
        return callRequireNonNull(defaultScheduler);
    }
    return applyRequireNonNull(f, defaultScheduler);
}

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

首先检查IOTask对象是否为空，然后调用callRequireNonNull方法调用IOTask.call()，并返回call()的返回值，即返回IoHolder.DEFAULT,IoHolder又是什么呢，原来是Schedulers的内部类，变量IO的本质原来是IoScheduler对象

// Schedulers.java
static final class IoHolder {
    static final Scheduler DEFAULT = new IoScheduler();
}

变量IO的身份我们已经知道了，回到一开始的io()看看RxJavaPlugins.onIoScheduler(IO)做了什么

// RxJavaPlugins.java
@NonNull
public static Scheduler onIoScheduler(@NonNull Scheduler defaultScheduler) {
    Function f = onIoHandler;
    if (f == null) { // f = null
        return defaultScheduler;
    }
    return apply(f, defaultScheduler);
}

由于onIoHandler是静态变量且没有初始化，所以为null，直接返回我们的变量IO。

所以io()方法最后返回的是IoScheduler对象。

接着看subscribeOn()

// Observable.java
public final Observable subscribeOn(Scheduler scheduler) {
    // 检查是否为 null
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
}

返回的是ObservableSubscribeOn对象，且保存了上游的被观察者和Scheduler对象

// ObservableSubscribeOn.java
public final class ObservableSubscribeOn extends AbstractObservableWithUpstream {
    final Scheduler scheduler;

    public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
        super(source); // source: 上游的被观察者
        this.scheduler = scheduler; // 本例子是 IoScheduler
    }
    ...
}

到此，subscribeOn()的方法已经看完了，最终返回一个ObservableSubscribeOn对象。

2. observeOn()

首先看看AndroidSchedulers.mainThread()怎么获取主线程操作的 scheduler

// AndroidSchedulers.java
public final class AndroidSchedulers {
    /** A {@link Scheduler} which executes actions on the Android main thread. */
    public static Scheduler mainThread() {
        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
    }
        
    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
        new Callable() {
            @Override public Scheduler call() throws Exception {
                return MainHolder.DEFAULT;
            }
    });
    ...
}

这里出现了一个静态变量MAIN_THREAD，且由RxAndroidPlugins初始化，代码如下

// RxAndroidPlugins.java
public static Scheduler initMainThreadScheduler(Callable scheduler) {
    if (scheduler == null) { // false
        throw new NullPointerException("scheduler == null");
    }
    Function, Scheduler> f = onInitMainThreadHandler;
    if (f == null) { // onInitMainThreadHandler 为 null
        return callRequireNonNull(scheduler);
    }
    return applyRequireNonNull(f, scheduler);
}

static Scheduler callRequireNonNull(Callable s) {
    try {
        // s : 传入 initMainThreadScheduler 的匿名对象
        Scheduler scheduler = s.call();
        if (scheduler == null) {
            throw new NullPointerException("Scheduler Callable returned null");
        }
        return scheduler;
    } catch (Throwable ex) {
        throw Exceptions.propagate(ex);
    }
}
  • 在initMainThreadScheduler()中最终执行callRequireNonNull(scheduler)
  • 把之前传入initMainThreadScheduler()的匿名对象作为 scheduler 传进callRequireNonNull
  • 然后返回scheduler.call()的返回值
  • 根据上面代码返回的是MainHolder.DEFAULT，MainHolder是AndroidSchedulers的静态类，DEFAULT创建代码如下
// AndroidSchedulers.java
private static final class MainHolder {
    // 通过 Looper.getMainLooper() 获取主线程的 Looper
    // 创建在主线程 Looper 上的 Handler
    // 用这个 Handler 创建 HandlerScheduler 对象
    static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));
}

DEFAULT其实就是一个拥有主线程Handler的HandlerScheduler对象，所以AndroidSchedulers.mainThread()最终返回的是HandlerScheduler对象。

下面回归到observeOn()

// Observable.java
public final Observable observeOn(Scheduler scheduler) {
    return observeOn(scheduler, false, bufferSize());
}

public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    ObjectHelper.verifyPositive(bufferSize, "bufferSize");
    // this : ObservableSubscribeOn
    return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize));
}

从上面代码可以看见observeOn最终返回的是ObservableObserveOn对象，且在我们的例子中这个对象拥有的 Scheduler 是HandlerScheduler

3. subscribe()

到这里我们知道本例子中被观察者是ObservableObserveOn

这个方法从之前两篇文章中知道它是一个启动方法，一旦调用，被观察者就开始发送事件给观察者，而且实际执行的方法是被观察者的subscribeActual()，还记得在我们的例子中最外层的被观察者是ObservableObserveOn所以我们从它的subscribeActual()中开始看起

// ObservableObserveOn.java
@Override
    protected void subscribeActual(Observer observer) {
    if (scheduler instanceof TrampolineScheduler) { // false
        source.subscribe(observer);
    } else {
        Scheduler.Worker w = scheduler.createWorker();
        // source : ObservableSubscribeOn
        source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
    }
}

在第二步我们知道ObservableObserveOn中的 scheduler 是HandlerScheduler，所以走 else ，首先执行了Scheduler.Worker w = scheduler.createWorker();，创建了HandlerScheduler.HandlerWorker对象

// HandlerScheduler.java
@Override
public Worker createWorker() {
    return new HandlerWorker(handler);
}

private static final class HandlerWorker extends Worker {
    private final Handler handler;
    
    private volatile boolean disposed;
    
    HandlerWorker(Handler handler) {
        this.handler = handler;
    }
    ...
}

在这里先不深入了解HandlerWorker，但是我们可以猜到worker是切换线程的关键。
接着看

source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));

这里的source是什么？还记得第一步调用subscribeOn()返回的ObservableSubscribeOn对象吗，第二步相当于调用了ObservableSubscribeOn.observeOn()到最后创建ObservableObserveOn对象的时候ObservableSubscribeOn赋值给了source。

由于ObservableSubscribeOn没有覆写subscribe()方法，所以source.subscribe()调用的是Observable.subscribe()

// Observable.java
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        // observer : ObserveOnObserver
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        ...
    }
}

最终会调用ObservableSubscribeOn的subscribeActual()

// ObservableSubscribeOn.java
@Override
public void subscribeActual(final Observer s) {
    // s : ObserveOnObserver
    // 创建 SubscribeOnObserver 包装了 s
    final SubscribeOnObserver parent = new SubscribeOnObserver(s);
    // 调用我们的回调方法 onSubscribe
    s.onSubscribe(parent);
    // scheduler : IoScheduler
    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(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) {
        this.actual = actual;
        this.s = new AtomicReference();
    }

    @Override
    public void onSubscribe(Disposable s) {
        DisposableHelper.setOnce(this.s, s);
    }
    
    void setDisposable(Disposable d) {
        DisposableHelper.setOnce(this, d);
    }
        
    // 省略以下方法
    // onNext onError onComplete dispose isDisposed
    ...
}

final class SubscribeTask implements Runnable {
    private final SubscribeOnObserver parent;

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

    @Override
    public void run() {
        // source : 我们创建的被观察者
        // parent : SubscribeOnObserver
        source.subscribe(parent);
    }
}

subscribeActual()只有三行代码，首先创建SubscribeOnObserver包装我们创建的观察者，然后调用我们的观察者回调方法onSubscribe()，而最后一行代码

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

是最重要的，这行代码的执行引起了一连串方法调用，激活了被观察者开始发射事件以及后面的一连串的操作，之后我们会在多个类里不停的跳转，见证着一系列动作。

这行代码分三步，但只需要关心前两步，第三步parent.setDisposable是设置Disposable，提供可断开被观察者和观察者连接的操作:

1. new SubscribeTask()

创建SubscribeTask，SubscribeTask 继承了 Runnable ，重点看下 run 方法里面是

source.subscribe(parent);

根据前面两篇文章我们知道这行代码会调用Observable.subscribeActual(observer),然后调用ObservableCreate. subscribeActual()

@Override
protected void subscribeActual(Observer observer) {
    CreateEmitter parent = new CreateEmitter(observer);
    observer.onSubscribe(parent);

    try {
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

最后调用我们创建被观察者时覆写的 subscribe 方法，从而激活了被观察者发射事件

Observable observable = Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter e) throws Exception {
        ...
});

所以我们可以预知随着代码的深入，SubscribeTask.run()将会在子线程中被调用，从而实现了被观察者在子线程中发射事件。

2. IoScheduler.scheduleDirect()

实际上调用的是IoScheduler父类Scheduler的scheduleDirect()

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

@NonNull
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    // w : EventLoopWorker
    final Worker w = createWorker();
    // run : SubscribeTask
    // decoratedRun : SubscribeTask
    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
        
    DisposeTask task = new DisposeTask(decoratedRun, w);
        
    w.schedule(task, delay, unit);
        
    return task;
}

// IoScheduler.java
@NonNull
@Override
public Worker createWorker() {
    return new EventLoopWorker(pool.get());
}
  • 先创建 worker
  • 把 SubscribeTask 包装后与 worker 组成 DisposeTask
  • 然后执行
w.schedule(task, delay, unit);

时执行的是 EventLoopWorker.schedule()，看看EventLoopWorker：

// IoScheduler.java
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()) { // false
            // 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;
    }
}

注意到构造方法里成员threadWorker是从CachedWorkerPool缓存池中获取的，EventLoopWorker.schedule()最终会调用NewThreadWorker.scheduleActual

// NewThreadWorker.java
@NonNull
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) {  // 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;
}


scheduleActual()内不做深入了解，只需要知道会执行下面这行代码


f = executor.submit((Callable)sr);


executor.submit()内部也不做深入介绍，只需要知道最终会在子线程调用SubscribeTask.run()证实了上文的猜测即可。


到了这里已经到达了我们的被观察者中发射事件的操作了，假设从网络请求中返回了数据可以通过onNext方法发射给观察者，那么接下来就看看在子线程中发射事件之后观察者是如何在主线程中接收事件并作出处理操作的。


// ObservableCreate.java
@Override
public void onNext(T t) {
    if (t == null) {
        onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
        return;
    }
    if (!isDisposed()) {
        observer.onNext(t);
    }
}



到这里我们会有疑问这个观察者是哪个？刚刚证实了被观察者发射事件的过程是放在SubscribeTask，现在回顾一下创建SubscribeTask时的代码


// ObservableSubscribeOn.java
@Override
public void subscribeActual(final Observer s) {
    // s : ObserveOnObserver
    // 创建 SubscribeOnObserver 包装了s
    final SubscribeOnObserver parent = new SubscribeOnObserver(s);
    // 调用我们的回调方法 onSubscribe
    s.onSubscribe(parent);
    // scheduler : IoScheduler
    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}



看完之后我们明白了原来顶层的观察者是SubscribeOnObserver，先我们看看它的构造方法，用变量actual保存了ObserveOnObserver对象


// ObservableSubscribeOn.SubscribeOnObserver
SubscribeOnObserver(Observer actual) {
    this.actual = actual;
    this.s = new AtomicReference();
}



看看SubscribeOnObserver的onNext()


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



里面调用了ObserveOnObserver.onNext()


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

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

void schedule() {
    if (getAndIncrement() == 0) {
        // worker : HandlerWorker
        // this : ObserveOnObserver
        worker.schedule(this);
    }
}



ObserveOnObserver内有一个队列 queue 用来保存收到的数据，然后调用schedule(),根据之前所说的观察者的worker是HandlerWorker，前面贴的代码并没有放schedule()这个方法，下面重新贴出来:


先调用父类Scheduler.worker的schedule()


// Scheduler.worker
@NonNull
public Disposable schedule(@NonNull Runnable run) {
    return schedule(run, 0L, TimeUnit.NANOSECONDS);
}



再调用HandlerWorker的schedule()


// HandlerScheduler.HandlerWorker
@Override
public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
    if (run == null) throw new NullPointerException("run == null");
    if (unit == null) throw new NullPointerException("unit == null");
    
    if (disposed) {
        return Disposables.disposed();
    }
    
    run = RxJavaPlugins.onSchedule(run);
    
    ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
    
    Message message = Message.obtain(handler, scheduled);
    message.obj = this; // Used as token for batch disposal of this worker's runnables.
    
    handler.sendMessageDelayed(message, Math.max(0L, unit.toMillis(delay)));
    
    // Re-check disposed state for removing in case we were racing a call to dispose().
    if (disposed) {
        handler.removeCallbacks(scheduled);
        return Disposables.disposed();
    }
    
    return scheduled;
}



其主要操作就是把ObserveOnObserver包装成ScheduledRunnable放进Message，然后通过HandlerWorker绑定的Handler(即主线程Handler)发送到消息队列等待处理。


这里有个疑问就是schedule()接收的是 Runnable 类型的参数，为什么我们可以把ObserveOnObserver传进去呢？之前没有贴完整的ObserveOnObserver代码，现在看看到底是什么东西


static final class ObserveOnObserver extends BasicIntQueueDisposable implements Observer, Runnable {
    ...
    @Override
    public void run() {
        if (outputFused) { // false
            drainFused();
        } else {
            drainNormal();
        }
    }
        
    void drainNormal() {
        int missed = 1;
    
        final SimpleQueue q = queue;
        final Observer a = actual;
    
        for (;;) {
            if (checkTerminated(done, q.isEmpty(), a)) {
                return;
            }
    
            for (;;) {
                boolean d = done;
                T v;
    
                try {
                    v = q.poll();
                } catch (Throwable ex) {
                    Exceptions.throwIfFatal(ex);
                    s.dispose();
                    q.clear();
                    a.onError(ex);
                    worker.dispose();
                    return;
                }
                boolean empty = v == null;
    
                if (checkTerminated(d, empty, a)) {
                    return;
                }
    
                if (empty) {
                    break;
                }
    
                a.onNext(v);
            }
    
            missed = addAndGet(-missed);
            if (missed == 0) {
                break;
            }
        }
    }
    ...
}



原来ObserveOnObserver也实现了Runnable，且run()里会调用drainNormal，就是把上面用来保存事件的队列 queue 都发送到观察者。




到这里我们已经把例子2切换线程的过程看了一遍，之前只是知道简单的调用两个方法就能随意切换线程，现在终于通过例子了解到里面的原理了。
























你可能感兴趣的:(RxJava 2.x 源码分析(三)之一步一步了解切换线程原理)






    

  • 美易官方：盘前道指期货涨0.5%，游戏驿站跌逾15%
美股投资
财经人工智能大数据新浪微博微信微信公众平台百度金融

    在股市开盘前的交易时段，道指期货上涨了0.5%，而游戏驿站（GameStop）的股价却出现了大幅下跌，跌幅超过15%。这一市场动态引发了投资者的广泛关注，也反映了当前股市的复杂性和不确定性。美股股指期货周三盘前走强，交易员为季度末的再平衡做准备。本周因假期而缩短，美国将公布关键通胀数据。道指期货涨0.5%，标普500指数期货涨0.6%，纳指期货涨0.5%。德国DAX指数涨0.4%，英国富时100指
    

    • 

  • 【Python】一文详细介绍 py格式 文件
高斯小哥
Python基础【高质量合集】python新手入门学习

    【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
    

    • 

  • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情
迷影咖啡

    作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
    

    • 

  • 迎接2019
唯有杜康1994

    告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
    

    • 

  • 植物小记
番茄秧子

    小时候，我养过一院子的花。今年，我重新开始从头开始养一点儿植物。别人说那也只是别人说临到快过年，我逛了一趟花市，买了两棵水仙花。路过另外一个卖水仙的摊位，霸气的卖花小妹瞧了一眼我捧着的那两棵弱小，说了一句：“你那个水仙不行，都不会开花的。”以我的脾气，这当然不能相信啊。结果，带回家好几天没动静。某一天早晨起来，两棵水仙悄不吭声全开了，然后香了屋子好多天。水仙三月，我在花市扛了一盆栀子花，花店老板见
    

    • 

  • 大学播音主持都学什么内容？播音主持专业学什么？
配音新手圈

    有些喜欢播音主持并且犹豫要不要报考这个大学专业的小伙伴们就会想要了解大学播音主持都学什么内容吧，毕竟如果不够了解就直接选择这个专业真的等选择完进去学习以后才知道这个专业并不是自己想要学习的东西那就来不及了。下面是小编为大家整理出来的一些播音主持专业学习的内容，请往下看吧。大学播音主持专业主要学习的课程有：播音发声、播音创作基础、广播播音主持、电视播音主持、文艺作品演播学概论、新闻学概论、新闻采编、
    

    • 

  • 数据结构奇妙旅程之深入解析快速排序
山间漫步人生路
数据结构排序算法算法

    快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
    

    • 

  • 被隔离的日子（五）@三七会写作营
三七会萍海临风

    从隔离的初期，我们三人都不适应，彼此说话都还火药味十足。后随着时间的推移，到现在，我们仨人能够心平气和，幽默地对待彼此。看来，时间可真是个好东西，不仅能见证一个人的心性，还能看清自己的需求、他人的本质。今天晚上，孩子跑到厨房，告诉我她给人捐款了。我纳闷，不是给河南捐过款了么。当时，我还落后于她捐的呢。这次又捐给谁？看到我一脸狐疑，孩子说，还记得初四给她补课的那个男老师么？当让记得，当时，就因为是男
    

    • 

  • 教育微创新的意蕴
知北老师

    我是1992年参加工作的，一毕业就被分配到一所全县最偏僻落后的农村学校——付窝中学，12年后被调往一所已经连续十年全县倒数第一，也是很偏僻落后的农村学校——北宋镇第三中学。三年后到了北宋镇第一中学工作，这所学校教学质量也是连续几年落后了。2014年我到了北京市育英学校，这所学校是京城名校。2016年7月，我被育英学校派往原密云区第七中学工作，这是一所城乡接合部薄弱学校。学校现名为北京市育英学校密云
    

    • 

  • android 自定义曲线图,Android自定义View——贝赛尔曲线
weixin_39767513
android自定义曲线图

    个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
    

    • 

  • Flink中的SQL Client和SQL Gateway
BigDataMLApplication
flinkflinksqlgateway

    Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
    

    • 

  • 拼多多纸巾推荐：品质与性价比的完美结合
氧惠帮朋友一起省

    拼多多纸巾推荐拼多多纸巾返现怎么做在我们的日常生活中，纸巾已经成为不可或缺的用品。无论是在家庭、办公室还是旅途中，纸巾都是我们随时随地需要的物品。随着电商平台的兴起，越来越多的人选择在网上购买纸巾。其中，拼多多作为国内知名的电商平台之一，以其独特的社交电商模式和实惠的价格吸引了大量用户。今天，我们就来探讨如何在拼多多上选择品质优良、性价比高的纸巾，以及如何通过一些小技巧来获取更多的优惠。一、品质与
    

    • 

  • word字号和mathtype磅值关系及批量修改
小铁匠-Ma
office小技巧经验分享

    word字号和mathtype磅值关系及批量修改1.字号与磅值关系字号「八号」对应磅值5字号「七号」对应磅值5.5字号「小六」对应磅值6.5字号「六号」对应磅值7.5字号「小五」对应磅值9字号「五号」对应磅值10.5字号「小四」对应磅值12字号「四号」对应磅值14字号「小三」对应磅值15字号「三号」对应磅值16字号「小二」对应磅值18字号「二号」对应磅值22字号「小一」对应磅值24字号「一号」对应
    

    • 

  • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    

    • 

  • 所有的突然想起，都是一直放在心里
清浅白芷

    一天，看到朋友圈发了一张木林的图片，熟悉而又陌生，心里怔住了一下，突然想起他以及往事。想起那年我们在旅途认识，而后又因旅途分开的故事。点点滴滴，在脑海里盘旋，在回忆里辗转。还记得相遇的那天，因为他的幽默风趣，把全场疲惫不堪的人逗笑了，他笑起来的样子不是很好看，但感觉很舒服。后来我们通过在网上联系，加深了对彼此的了解，便互生情愫，然后恋爱。只是后来，经过一年多的相处，我们就分开了。虽然时间很短，但仿
    

    • 

  • 为什么说仪式和习惯非常重要？
章鱼老师zy

    这是章鱼姐第【40】篇原创文章，日更计划第【37/100】天。阅读张萌萌姐【精力管理手册】第【6/7】章。一阅读摘要这一章萌姐讲到了习惯的重要性，为什么说养成一个习惯很重要？如何养成一个好习惯？如何建立自己的仪式感？二金句精力管理最重要的是产生什么效果。当你想做却没有动力去做一件事情时，你就应该把它养成习惯。习惯可以帮我们创造稳定框架。对于那些特别考验意志的事情，我们应该先行后思。三思考题，萌姐讲
    

    • 

  • 第一章 山洞传来牛铃声
满眼荷花

    春夏时节，田野一片青碧，山林薄雾蔼蔼，水草萋萋的小河边静静立着一只白鹭，像一位白头钓翁，在耐心地等鱼。王三乐牵着一头老黄牛，正在河边田埂上放牛。看见白鹭，他百无聊赖地捡起一块小石头扔了过去。白鹭动作舒缓、姿势优美地飞起避过，在空中飞行一段后，宛若晴空一片云，翩然而下，又静静立于河边青草间，继续呈现完美的画面。王三乐也觉得自己很无聊，这也难怪，从他记事起就开始放牛，一直到现在都大学毕业了，还没丢下放
    

    • 

  • 12-25
yummy0632

    72.4kg早饭：一碗面条，俩鸡蛋，三个砂糖桔。五天过去了，这本书我听完了。哈哈简直了。真兴奋，我准备好了，迎接新的自己。午饭：一个花卷，一碗汤，一份油菜，一份冬瓜粉条，一份红烧肉。晚饭：一个花卷，一份芹菜，一份土豆，一份鸭子。很咸。
    

    • 

  • 以前开发MFC界面如何快速转成QT界面
广州视觉芯软件有限公司
mfcqtc++

    将MFC界面快速转换为Qt界面可能需要进行一些手动工作，因为MFC和Qt是两个不同的界面框架，它们具有不同的设计和实现原理。但是，以下步骤可以帮助你快速进行转换：创建一个新的Qt项目：使用QtCreator创建一个新的Qt项目。分析MFC界面：仔细分析你的MFC界面，包括窗口、对话框、控件等的布局、样式和行为。重新设计界面：使用Qt的可视化设计器重新设计界面。在QtCreator的设计器中，你可以
    

    • 

  • 2022-10-02
朗月斋主

    肿瘤溶解病毒（OVs）作为一种新型的免疫治疗和治疗辅助剂，在制药行业中越来越受到关注，因为它们能够通过多种机制诱导和提高抗肿瘤免疫力。首先，OVs能够利用宿主免疫系统的内在机制（例如，逃避免疫检测）可以使肿瘤的免疫逃逸机制失效。第二，许多类型的OVs已被证明可以直接裂解肿瘤细胞，从而诱导出由肿瘤相关抗原和危险信号分子释放介导的肿瘤特异性T细胞反应。第三，表达免疫刺激治疗基因的武装OV可以在肿瘤组织
    

    • 

  • 购物返利平台是真的吗
返金app平台高佣返利省钱

    购物返利平台是真实存在的，它们提供一种通过购物来获取一定比例返现的服务。这些平台通常与商家合作，通过返利链接或其他追踪方式来追踪用户的购物行为，然后将一部分返现金额返还给用户。然而，需要注意的是，并非所有的购物返利平台都是可信的。在选择使用购物返利平台时，建议您注意以下几个方面：可信度和口碑：查看平台的用户评价和口碑，了解其他用户对该平台的使用体验和返利情况。合作商家：了解平台的合作商家是否可靠，
    

    • 

  • 1.计算机处理器架构+嵌入式处理器架构及知识
vv 啊
arm-linux学习linux系统架构

    目录一：x86-64处理器架构二：Intel80386处理器（i386）1.i3862.i686三：嵌入式Linux知识：1.MinGW2.GNU计划2.1GNU工具链概述此次只分享英特尔和ADM处理器有关于x86的架构，至于嵌入式处理器架构请查看https://en.wikipedia.org/wiki/List_of_ARM_processors一：x86-64处理器架构x86-64，也称为x
    

    • 

  • 夫子庙前的金子招牌
光中的cici

    古城都不乏老招牌，比如苏杭，比如南京。随便一个都有久远的年代。夫子庙前，乌衣巷口，店肆成市招牌林立繁华重归来。难为我一个外地人，究竟该喝谁家的那碗鸭血粉丝汤呢？在网上研究了半天，选了秦淮人家。只因为三点：一，临河就着秦淮河喝鸭血汤就着秦淮河喝鸭血汤二，装修较其他一溜大白墙的店算讲究的了，我特别吃环境，没办法～三，有鸭血汤鸭血汤倒是有，夹杂在一套所谓的套餐里，不允许单独点菜。我是为了这秦淮河买的单，
    

    • 

  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】
还算善良_
私有代码库工具类javalist数据结构

    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
    

    • 

  • 浙江女大学生“卖淫日记”曝光，震惊全网：背后还藏着一个真相
地球上的星星_272e

    作者/在风来源/微信公众号：自黑思维最近，一个新闻震碎无数人的三观：在浙江农林大学，有一位女大学生，在网上公开自己的“卖淫日记”，无论是文字还是图片，都非常露骨。而目前关于这事的瓜，都已经被删得七七八八，但我有保留截图的习惯，所以才有了这篇文章。首先，必须要强调的一点，就是这事不是谣传，是真的，学校已经出来证实过。只是学校表示该名女学生有精神病。但到底是不是真的精神有问题？我们可以从她的日记里，略
    

    • 

  • keras.optimizers优化器中文文档
地上悬河
python开发语言后端

    优化器optimizers优化器是编译Keras模型必要的两个参数之一model=Sequential()model.add(Dense(64,init='uniform',input_dim=10))model.add(Activation('tanh'))model.add(Activation('softmax'))sgd=SGD(lr=0.01,decay=1e-6,momentum=0.
    

    • 

  • 2021.12.13 自律日记
夏舒帅然a

    深感时光转瞬即逝，如指缝流金！自律、习惯养成、执行力提高迫在眉睫！今天是什么日子：平日艳阳天起床：7：50任务清单（明日）1.起床：7:302.就寝：10：103.读书30分钟4.打两套太极5.两次静坐（每次15分钟）昨日完成的任务情况，最重要的三件事一.读书30分。未完成二.就寝10：00完成三.起床7：30未完成四.打两套太极未完成五.两次静坐（每次15分钟）未完成习惯养成：早睡早起、每日读书
    

    • 

  • ChatGPT一路狂飙？
何鲸洛

    2月2日。根据投行瑞银集团在周三发布的一份研究报告。爆红聊天机器人ChatGPT的月活跃用户在今年1月份预计达到了1亿，这距离它推出只有2个月时间，成为史上增长最快的消费者应用。①ChatGPT一路火花带闪电？▽2014年。OpenAI创始人SamAltman早年曾执掌著名的硅谷孵化器YCombinator。2015年。Altman联合马斯克、彼得·泰尔、AWS、印度Infosys和YC等作为出资
    

    • 

  • 【美丽特色乡村】，景德镇马鞍岭村，
粒子飞翔

    【美丽特色乡村】，景德镇马鞍岭村，就像是陶渊明笔下的山水田园，阡陌交通，精美的白房参差错落，碧绿透亮的河水从不远处的深涧里连绵不绝流入此地，滋养着土里。成群的白鸭悠闲地在河水里戏水，人与环境达成和谐的境界。借助三宝国际瓷谷建设的契机，马鞍岭村迎来了天翻地覆的沧桑巨变,此地以陶瓷文化为特色，融合原来生态资源，修复了水碓遗址、矿坑遗址等历史文化遗产，提升生态环境现状。同时，依托三宝溪围绕整个村落，对河
    

    • 

  • yarn的安装和使用全网最详细教程
zxj19880502
yarnnpm

    一、yarn的简介：Yarn是facebook发布的一款取代npm的包管理工具。二、yarn的特点：速度超快。Yarn缓存了每个下载过的包，所以再次使用时无需重复下载。同时利用并行下载以最大化资源利用率，因此安装速度更快。超级安全。在执行代码之前，Yarn会通过算法校验每个安装包的完整性。超级可靠。使用详细、简洁的锁文件格式和明确的安装算法，Yarn能够保证在不同系统上无差异的工作。三、yarn的
    

    • 

  • html
周华华
html

    js
1，数组的排列
var arr=[1,4,234,43,52,];
for(var x=0;x<arr.length;x++){
   for(var y=x-1;y<arr.length;y++){
     if(arr[x]<arr[y]){
    &
    

    • 

  • 【Struts2 四】Struts2拦截器
bit1129
struts2拦截器

    Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。
 
Struts2中自定义拦截器的步骤是：
    

    • 

  • make:cc 命令未找到解决方法
daizj
linux命令未知make cc

    安装rz sz程序时，报下面错误：
 
[root@slave2 src]# make posix
cc   -O -DPOSIX -DMD=2 rz.c -o rz
make: cc：命令未找到
make: *** [posix] 错误 127
 
系统：centos 6.6
环境：虚拟机
 
错误原因：系统未安装gcc，这个是由于在安
    

    • 

  • Oracle之Job应用
周凡杨
oracle job

    
最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。
 
一：查看相关job信息
   1、相关视图 
dba_jobs 
all_jobs 
user_jobs 
dba_jobs_running 包含正在运行
    

    • 

  • 多线程机制
朱辉辉33
多线程

    转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx
程序、进程和线程：
程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
    

    • 

  • web报表工具FineReport使用中遇到的常见报错及解决办法（一）
老A不折腾
web报表finereportjava报表报表工具

    FineReport使用中遇到的常见报错及解决办法（一）
这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。
 
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。
 
1、address pool is full：
含义：地址池满，连接数超过并发数上
    

    • 

  • mysql rpm安装后没有my.cnf
林鹤霄
没有my.cnf

    Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的，
至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法，
第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动，
第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
    

    • 

  • Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题
aigo
root

    原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/
 
Step 4: Run ADB command from your PC
 
On the PC, you need install Amazon Fire ADB driver and instal
    

    • 

  • javascript 中var提升的典型实例
alxw4616
JavaScript

    // 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧
myname = 'global';
var fn = function () {
console.log(myname); // undefined
var myname = 'local';
console.log(myname); // local
};
fn()
// 上述代码实际上等同于以下代码
m
    

    • 

  • 定时器和获取时间的使用
百合不是茶
时间的转换定时器

    定时器:定时创建任务在游戏设计的时候用的比较多
  Timer();定时器
TImerTask();Timer的子类  由 Timer 安排为一次执行或重复执行的任务。
 
 
  定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
    

    • 

  • JDK1.5 Queue
bijian1013
javathreadjava多线程Queue

    JDK1.5 Queue
LinkedList：
LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
    

    • 

  • http认证原理和https
bijian1013
httphttps

    一.基础介绍
        在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。
        Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。
http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
    

    • 

  • 【Java范型五】范型继承
bit1129
java

    定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2
 
package com.tom.lang.generics;
public abstract class SuperGenerics<T1, T2> {
private T1 t1;
private T2 t2;
public abstract void doIt(T
    

    • 

  • 【Nginx六】nginx.conf常用指令(Directive)
bit1129
Directive

    1. worker_processes    8;
表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行
 
nobody 53879 118449 0 Apr22 ? 00:26:15 nginx: worker process 
    

    • 

  • lua 遍历Header头部
ronin47
lua header 遍历　

    
local headers = ngx.req.get_headers()  
ngx.say("headers begin", "<br/>")  
ngx.say("Host : ", he
    

    • 

  • java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。
bylijinnan
java

    
import java.util.Arrays;
public class MinSumASumB {
/**
* Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序.
*
* 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。
* 例如:
* int[] a = {100,99,98,1,2,3
    

    • 

  • redis
开窍的石头
redis

    在redis的redis.conf配置文件中找到# requirepass foobared
把它替换成requirepass 12356789 后边的12356789就是你的密码
打开redis客户端输入config get requirepass
返回
redis 127.0.0.1:6379> config get requirepass
1) "require
    

    • 

  • [JAVA图像与图形]现有的GPU架构支持JAVA语言吗？
comsci
java语言

    
      无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情
       
    

    • 

  • 安装ubuntu14.04登录后花屏了怎么办
cuiyadll
ubuntu

    这个情况，一般属于显卡驱动问题。
可以先尝试安装显卡的官方闭源驱动。
按键盘三个键：CTRL + ALT  +  F1
进入终端，输入用户名和密码登录终端：
安装amd的显卡驱动
sudo 
apt-get 
install 
fglrx
安装nvidia显卡驱动
sudo 
ap
    

    • 

  • SSL 与 数字证书 的基本概念和工作原理
darrenzhu
加密ssl证书密钥签名

    SSL 与 数字证书 的基本概念和工作原理
http://www.linuxde.net/2012/03/8301.html
SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。
http://www.ibm.com/developerworks/cn/webspher
    

    • 

  • Ubuntu设置ip的步骤
dcj3sjt126com
ubuntu

    在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。
转载不是错：
Ubuntu命令行修改网络配置方法
/etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载.
1. 以D
    

    • 

  • php包管理工具推荐
dcj3sjt126com
PHPComposer

    http://www.phpcomposer.com/
  Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。
中文文档 
入门指南 
下载 
安装包列表
Composer 中国镜像 
    

    • 

  • Gson使用四（TypeAdapter）
eksliang
jsongsonGson自定义转换器gsonTypeAdapter

    转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述
       Gson的TypeAapter可以理解成自定义序列化和返序列化 二、应用场景举例
       例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
    

    • 

  • JQM控件之Navbar和Tabs
gundumw100
htmlxmlcss

    在JQM中使用导航栏Navbar是简单的。
只需要将data-role="navbar"赋给div即可：
<div data-role="navbar">
<ul>
<li><a href="#" class="ui-btn-active&qu
    

    • 

  • 利用归并排序算法对大文件进行排序
iwindyforest
java归并排序大文件分治法Merge sort

     
归并排序算法介绍，请参照Wikipeida
zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F
基本思想：
大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数
低于限制行数的子文件直接排序
两个排序好的子文件归并到父文件
直到最后所有排序好的父文件归并到输入
    

    • 

  • iOS UIWebView URL拦截
啸笑天
UIWebView

    本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
    

    • 

  • 索引的碎片整理SQL语句
macroli
sql

    SET NOCOUNT ON
DECLARE @tablename VARCHAR (128)
DECLARE @execstr VARCHAR (255)
DECLARE @objectid INT
DECLARE @indexid INT
DECLARE @frag DECIMAL
DECLARE @maxfrag DECIMAL
--设置最大允许的碎片数量,超过则对索引进行碎片
    

    • 

  • Angularjs同步操作http请求with $promise
qiaolevip
每天进步一点点学习永无止境AngularJS纵观千象

    // Define a factory
app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) {
var deferred = $q.defer();
AccountService.getProfile().then(function(res) {

    

    • 

  • hibernate联合查询问题
sxj19881213
sqlHibernateHQL联合查询

    最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。
针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2）
 
1 几个常识：
 （1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。
 （2）hql的默认查询策略，在进行联合查询时，会产
    

    • 

  • struts2.xml
wuai
struts

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache
    

    •