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 源码分析(三)之一步一步了解切换线程原理)

        

            

                
    
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 想家
                        爆米花机

                        
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • 爬山后遗症
                        璃绛

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                    
  • 《策划经理回忆录之二》
                        路基雅虎

                        
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • 向内而求
                        陈陈_19b4

                        
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    
                    
    • 
                    
  • 三大师传
                        beca酱

                        
    巴尔扎克的作品被誉为“法国社会的一面镜子”。文学大师维克多·雨果对巴尔扎克的评价是：“在最伟大的人物中间，巴尔扎克是名列前茅者；在最优秀的人物中间，巴尔扎克是佼佼者之一。”一个原本寂寂无名的小人物，从地中海的某个海岛上，只身一人来到巴黎，没有朋友，也没有名望。作为一个一文不名的外乡人，凭着赤手空拳赢得了巴黎，征服了整个法兰西，并且赢得了世界。这个人就是十九世纪法国伟大的军事家、政治家，法兰西第一帝
    
                    
    • 
                    
  • 开心
                        蒋泳频

                        
    从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 放下是一段成长的修行
                        小莳玥

                        
    人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • 谁家酒器最绝唱，藏在酒厂人未知？景阳冈酒厂先秦藏品大揭秘
                        李虓酒评论

                        
    文/王赛时中国的酒器酒具历史久远，举世闻名。从北京的故宫博物院、中国国家博物馆，到世界各国的大型博物馆，都以能够收藏中国古代酒具而夸耀。但很少有人知道，在山东阳谷景阳冈酒厂，默默地收藏了两千件中国酒器。这些酒器，就封藏在景阳冈的酒道馆里。其中有一些青铜酒器，一睡就是三、四千年，堪称无声国宝，堪作无字史书！今天，我将引领诸位首先窥视一下景阳冈酒道馆的9件先秦藏品，你自己来说震撼不震撼。提示：这只是景
    
                    
    • 
                    
  • LLM 词汇表
                        落难Coder
LLMsNLP大语言模型大模型llama人工智能
                        
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
    
                    
    • 
                    
  • 我的黑历史
                        袖手围观有来有去

                        
    孩子同学与我们一起共进晚餐，俩孩子加我三个人。小同学是一个大方率性礼貌的小孩，我们也都非常喜欢。好了，回到正题上来让我把这个故事讲完。俩孩子都喜欢吃鱼，所以就发生了小孩子之间常会发生的事。我狠狠的盯了我家孩子，孩子表情有些狼狈。和孩子单独一起的时候，见她尚未释怀，并谴责我不该狠盯她，让她没面子。也许是她触动了我的童年往事吧。由此，一狠心，给她讲了一段埋藏心里极深的黑历史：我奶奶有四个儿子，四个儿子
    
                    
    • 
                    
  • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    
                    
    • 
                    
  • 2020.11.19
                        隆非凡

                        
    日精进，今日体验：在维修过程中遇到的问题，把源头找到，在进行下一步开始。不要停留在一个点上，合理调整心态，把当下事做好。
    
                    
    • 
                    
  • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    
                    
    • 
                    
  • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    
                    
    • 
                    
  • SQL Server_查询某一数据库中的所有表的内容
                        qq_42772833
SQLServer数据库sqlserver
                        
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
    
                    
    • 
                    
  • 如果做到轻松在股市赚钱？只要坚持这三个原则。
                        履霜之人

                        
    大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
    
                    
    • 
                    
  • 《人世间》
                        南询yi

                        
    今日分享十点推文，《人世间》有感苏格拉底说：“天地只有三尺，而人在五尺开外，所以人人都要懂得低头。”深以为然。懂得低头，不是认输。而是于人世间找寻温存的成熟，于困境中寻觅柳暗花明的智慧，于争执中展示屈伸自如的格局。正如仰头不是骄傲，是要看见自己的天空；低头也不是认输，而是要看清自己的路。成大事者，不仅要抬头挺胸，还得低头看路。懂得低头，进退有度，不是认输，而是竭尽全力过好这一生。宫崎骏说过：“所有
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 运城寻访重逢石头纪实【严建设老照片395 集】 我简直能把你想透， 当我走进运城的时候。 我已急得热汗直流， 访问了十九个老头， 把晋南的小城转了三周。 虽然是悠久的思旧， 我仍然是牛样的执...
                        严建设

                        
    运城寻访重逢石头纪实【严建设老照片395集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执拗。说什么变换的世情，泛起了过去的逝流，你就是真正的故友。踏破铁鞋的淡愁，已化为不废功夫的范畴，是就像远在天涯近在咫尺，就像是梦乡的邂逅，我紧紧地攥着你的手。你已长成了高高的个头，俊逸的容颜却很清瘦，你那样顽皮的童音，已变到老
    
                    
    • 
                                
  • 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
    
                                
    •