binaryshao
binaryshao

【源码分析】RxJava 1.2.2 实现简单事件流的原理

目前RxJava已经被广泛用于Android开发中，GitHub地址在这，官方文档说2018.03.31停止维护1.x 版本，本篇文章基于RxJava 1.2.2。

关于RxJava的介绍文章推荐看扔物线的给 Android 开发者的 RxJava 详解，这篇文章讲解了很多使用方法、结论和部分原理，虽然是两年前的文章，但现在看还是有不少的收获。

常用的类和接口

在正式开始分析之前，我们先来回顾一下RxJava中常用的一些类和接口，以利于后面的分析。

被观察者-类Observable，RxJava中核心的类，事件的生产者，它的大量操作符可以将一个Observable转换为另一个Observable。它有一个成员变量onSubscribe。

public class Observable<T> {

    final OnSubscribe onSubscribe;

    public interface OnSubscribe<T> extends Action1<Subscribersuper T>> {
        // cover for generics insanity
    }
}

观察者-接口Observer，事件的消费者。

public interface Observer {

    void onCompleted();

    void onError(Throwable e);

    void onNext(T t);
}

订阅-接口Subscription，被观察者和观察者形成订阅关系后，就有返回一个订阅，便于取消订阅。

public interface Subscription {

    void unsubscribe();

    boolean isUnsubscribed();
}

订阅者-抽象类Subscriber，实现了接口Observer和Subscription ，所以它可以接收事件，也可以取消订阅。事实上，在订阅过程中，Observer 也总会先被转换成一个 Subscriber 再使用。

public abstract class Subscriber<T> implements Observer<T>, Subscription {
    public void onStart() {
        // do nothing by default
    }
}

接口Function、Action系列，这些接口都有一个call()方法，接口名中的数字代表call()方法中的参数个数，区别在于Function系列的方法有返回值，而Action系列的方法没有返回值。

public interface Function {

}

public interface Func1<T, R> extends Function {
    R call(T t);
}

public interface Action extends Function {

}

public interface Action1<T> extends Action {
    void call(T t);
}

简单的事件流

下面的例子可以说是最简单的使用示例，创建一个被观察者，然后和观察者形成订阅关系。订阅后，被观察者调用3次onNext()方法，然后结束。本篇文章就从这段简单的代码入手，探究RxJava背后的原理。

Observable
        .create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscribersuper String> subscriber) {
                subscriber.onNext("消息1");
                subscriber.onNext("消息2");
                subscriber.onNext("消息3");
                subscriber.onCompleted();
            }
        })
        .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.println("任务结束");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("任务出错");
            }

            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
        });

create()

public static  Observable create(OnSubscribe f) {
    return new Observable(RxJavaHooks.onCreate(f));
}

protected Observable(OnSubscribe f) {
    this.onSubscribe = f;
}

第2行有一个RxJavaHooks，之后我们会看到在RxJava中hook频繁地出现，它的返回值类型和入参类型都一样。为简化分析，抓住重点，本篇文章不会对hook相关部分深入探究。

第5行将对成员变量onSubscribe赋值。

很明显，create()方法的作用就是将传入的onSubscribe赋值给成员变量onSubscribe。

subscribe()

public final Subscription subscribe(Subscribersuper T> subscriber) {
    return Observable.subscribe(subscriber, this);
}

static  Subscription subscribe(Subscribersuper T> subscriber, Observable observable) {
 // validate and proceed
    if (subscriber == null) {
        throw new IllegalArgumentException("subscriber can not be null");
    }
    if (observable.onSubscribe == null) {
        throw new IllegalStateException("onSubscribe function can not be null.");
        /*
         * the subscribe function can also be overridden but generally that's not the appropriate approach
         * so I won't mention that in the exception
         */
    }

    // new Subscriber so onStart it
    subscriber.onStart();

    /*
     * See https://github.com/ReactiveX/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls
     * to user code from within an Observer"
     */
    // if not already wrapped
    if (!(subscriber instanceof SafeSubscriber)) {
        // assign to `observer` so we return the protected version
        subscriber = new SafeSubscriber(subscriber);
    }

    // The code below is exactly the same an unsafeSubscribe but not used because it would
    // add a significant depth to already huge call stacks.
    try {
        // allow the hook to intercept and/or decorate
        RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
        return RxJavaHooks.onObservableReturn(subscriber);
    } catch (Throwable e) {
        // special handling for certain Throwable/Error/Exception types
        Exceptions.throwIfFatal(e);
        // in case the subscriber can't listen to exceptions anymore
        if (subscriber.isUnsubscribed()) {
            RxJavaHooks.onError(RxJavaHooks.onObservableError(e));
        } else {
            // if an unhandled error occurs executing the onSubscribe we will propagate it
            try {
                subscriber.onError(RxJavaHooks.onObservableError(e));
            } catch (Throwable e2) {
                Exceptions.throwIfFatal(e2);
                // if this happens it means the onError itself failed (perhaps an invalid function implementation)
                // so we are unable to propagate the error correctly and will just throw
                RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
                // TODO could the hook be the cause of the error in the on error handling.
                RxJavaHooks.onObservableError(r);
                // TODO why aren't we throwing the hook's return value.
                throw r; // NOPMD
            }
        }
        return Subscriptions.unsubscribed();
    }
}

第19行调用了subscriber的onStart()方法，我们可以在这个方法里做一些准备工作。

第35行调用了onSubscribe的call()方法，参数为Subscriber， 这个方法来自于它继承的接口Action1，而我们在call()方法中调用了观察者的onNext()、onCompleted()方法，被观察者开始发送事件，由此实现了事件由被观察者向观察者的传递。

这里分析的Observable是由create()方法创建的，我们手动在call()方法中调用了观察者的onNext()、onCompleted()方法。Observable也可以由just()、from()方法创建，这些方法创建的被观察者会自动调用观察者的onNext()、onCompleted()、onError方法，我们只需要传入简单的参数就可以了，但本质上和用create()方法创建是一样的。

subscribe()的不同重载方法还接受Action1、Observer形式的参数，但它们都会被转换为Subscriber，最终进入刚才分析的subscribe()方法中。

至此，一次简单的事件流就清楚了：

  1. 赋值给成员变量onSubscribe
  2. 调用subscribe()方法订阅，回调onSubscribe的call()方法，传入Subscriber作为参数，于是在call()方法中可以调用Subscriber的相关方法发送事件。
  3. 注意：只有在订阅后才开始发送事件。

线程调度

Observable中有大量的操作符可以实现变换，一般用的最多的估计就是线程调度了。我们给之前的例子加上Android中常用的线程切换：

Observable
        .create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscribersuper String> subscriber) {
                subscriber.onNext("消息1");
                subscriber.onNext("消息2");
                subscriber.onNext("消息3");
                subscriber.onCompleted();
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.println("任务结束");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("任务出错");
            }

            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
        });

注意：使用AndroidSchedulers.mainThread()需要导入RxAndroid。

我们来分析这段代码中线程调度实现的原理，接下来涉及的源码比较多，我们从序号1开始对源码片段作标记。

subscribeOn()

//第1段代码
public final Observable subscribeOn(Scheduler scheduler) {
     if (this instanceof ScalarSynchronousObservable) {
         return ((ScalarSynchronousObservable)this).scalarScheduleOn(scheduler);
     }
     return create(new OperatorSubscribeOn(this, scheduler));
 }

可以看到，调用subscribeOn()方法后返回了一个新的Observable。

第3行的判断在此时为false，我们直接看第6行，这个OperatorSubscribeOn是新的Observable的OnSubscribe，跟进OperatorSubscribeOn一探究竟。

//第2段代码
//rx.internal.operators.OperatorSubscribeOn
public final class OperatorSubscribeOn implements OnSubscribe {

    final Scheduler scheduler;
    final Observable source;

    public OperatorSubscribeOn(Observable source, Scheduler scheduler) {
        this.scheduler = scheduler;
        this.source = source;
    }

    @Override
    public void call(final Subscriber subscriber) {
        final Worker inner = scheduler.createWorker();
        subscriber.add(inner);

        inner.schedule(new Action0() {
            @Override
            public void call() {
                final Thread t = Thread.currentThread();

                Subscriber s = new Subscriber(subscriber) {
                    @Override
                    public void onNext(T t) {
                        subscriber.onNext(t);
                    }

                    @Override
                    public void onError(Throwable e) {
                        try {
                            subscriber.onError(e);
                        } finally {
                            inner.unsubscribe();
                        }
                    }

                    @Override
                    public void onCompleted() {
                        try {
                            subscriber.onCompleted();
                        } finally {
                            inner.unsubscribe();
                        }
                    }

                    @Override
                    public void setProducer(final Producer p) {
                        subscriber.setProducer(new Producer() {
                            @Override
                            public void request(final long n) {
                                if (t == Thread.currentThread()) {
                                    p.request(n);
                                } else {
                                    inner.schedule(new Action0() {
                                        @Override
                                        public void call() {
                                            p.request(n);
                                        }
                                    });
                                }
                            }
                        });
                    }
                };

                source.unsafeSubscribe(s);
            }
        });
    }
}

在构造方法中，第9行和第10行分别保存了传入的Observable和Scheduler。

OperatorSubscribeOn作为新的Observable的OnSubscribe，根据之前对subscribe()方法的分析，它的call()方法将在订阅后被回调。那我们就来看一下它的call方法：

第15行创建了Worker类型的变量inner，为保持主逻辑的清晰，暂时先不管Worker是什么，继续看主逻辑。

先透露一下，调用第18行的schedule()方法后，最终将进入第20行的call()方法。

第23行创建了一个Subscriber，第67行的source就是刚才构造方法中传入的Observable，即上游Observable，这里将刚才创建的Subscriber作为参数传入了它的unsafeSubscribe()方法，继续跟进：

//第3段代码
//rx.Observable
public final Subscription unsafeSubscribe(Subscribersuper T> subscriber) {
    try {
        // new Subscriber so onStart it
        subscriber.onStart();
        // allow the hook to intercept and/or decorate
        RxJavaHooks.onObservableStart(this, onSubscribe).call(subscriber);
        return RxJavaHooks.onObservableReturn(subscriber);
    } catch (Throwable e) {
        // special handling for certain Throwable/Error/Exception types
        Exceptions.throwIfFatal(e);
        // if an unhandled error occurs executing the onSubscribe we will propagate it
        try {
            subscriber.onError(RxJavaHooks.onObservableError(e));
        } catch (Throwable e2) {
            Exceptions.throwIfFatal(e2);
            // if this happens it means the onError itself failed (perhaps an invalid function implementation)
            // so we are unable to propagate the error correctly and will just throw
            RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
            // TODO could the hook be the cause of the error in the on error handling.
            RxJavaHooks.onObservableError(r);
            // TODO why aren't we throwing the hook's return value.
            throw r; // NOPMD
        }
        return Subscriptions.unsubscribed();
    }
}

从方法名能猜出这也是一个订阅方法，第6行更是和之前分析的subscribe()方法进行了相同的操作，调用了上游Observable的onSubscribe的call()方法。

回到第2段代码，第26、32、41行的代码分别调用了下游Subscriber的对应方法。

至此，我们可以明白subscribeOn()究竟做了什么：

  1. 该方法返回了一个新的Observable
  2. 新的Observable收到订阅回调后，回调上游Observable的onSubscribe的call()方法。
  3. 新的Observable中的OnSubscribe的call回调中新建的Subscriber接收到事件后，继续将事件传递给下游的Subscriber。

那说好的子线程切换又在哪里呢？

我们再回过头看第2段代码的Worker类，它由Scheduler创建而来。我们这里使用的Scheduler是Schedulers.io()，跟进看一下：

//第4段代码
//rx.schedulers.Schedulers 只拷贝了相关核心代码
public final class Schedulers {
    private final Scheduler ioScheduler;

    public static Scheduler io() {
        return RxJavaHooks.onIOScheduler(getInstance().ioScheduler);
    }

    private Schedulers() {
       @SuppressWarnings("deprecation")
       RxJavaSchedulersHook hook = RxJavaPlugins.getInstance().getSchedulersHook();

       Scheduler c = hook.getComputationScheduler();
       if (c != null) {
           computationScheduler = c;
       } else {
           computationScheduler = RxJavaSchedulersHook.createComputationScheduler();
       }

       Scheduler io = hook.getIOScheduler();
       if (io != null) {
           ioScheduler = io;
       } else {
           ioScheduler = RxJavaSchedulersHook.createIoScheduler();
       }

       Scheduler nt = hook.getNewThreadScheduler();
       if (nt != null) {
           newThreadScheduler = nt;
       } else {
           newThreadScheduler = RxJavaSchedulersHook.createNewThreadScheduler();
       }
   }
}

第25行表明了ioScheduler的出处：

//第5段代码
//rx.plugins.RxJavaSchedulersHook 只拷贝了相关核心代码
public class RxJavaSchedulersHook {
    public static Scheduler createIoScheduler() {
        return createIoScheduler(new RxThreadFactory("RxIoScheduler-"));
    }

    public static Scheduler createIoScheduler(ThreadFactory threadFactory) {
        if (threadFactory == null) {
            throw new NullPointerException("threadFactory == null");
        }
        return new CachedThreadScheduler(threadFactory);
    }
}

第5行的 “RxIoScheduler-“是子线程的前缀，如果调试日志中有输出这个信息，那就会看到这个前缀。

第12行使用这个ThreadFactory构建了一个CachedThreadScheduler，继续跟进：

//第6段代码
//rx.internal.schedulers.CachedThreadScheduler 只拷贝了相关核心代码 
public final class CachedThreadScheduler extends Scheduler implements SchedulerLifecycle {

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

    public CachedThreadScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
        this.pool = new AtomicReference(NONE);
        start();
    }

    @Override
    public void start() {
        CachedWorkerPool update =
            new CachedWorkerPool(threadFactory, KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT);
        if (!pool.compareAndSet(NONE, update)) {
            update.shutdown();
        }
    }

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

    static final class EventLoopWorker extends Scheduler.Worker implements Action0 {
        private final CompositeSubscription innerSubscription = new CompositeSubscription();
        private final CachedWorkerPool pool;
        private final ThreadWorker threadWorker;
        final AtomicBoolean once;

        EventLoopWorker(CachedWorkerPool pool) {
            this.pool = pool;
            this.once = new AtomicBoolean();
            this.threadWorker = pool.get();
        }

        @Override
        public void unsubscribe() {
            if (once.compareAndSet(false, true)) {
                // unsubscribe should be idempotent, so only do this once

                // Release the worker _after_ the previous action (if any) has completed
                threadWorker.schedule(this);
            }
            innerSubscription.unsubscribe();
        }

        @Override
        public void call() {
            pool.release(threadWorker);
        }

        @Override
        public boolean isUnsubscribed() {
            return innerSubscription.isUnsubscribed();
        }

        @Override
        public Subscription schedule(Action0 action) {
            return schedule(action, 0, null);
        }

        @Override
        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
            if (innerSubscription.isUnsubscribed()) {
                // don't schedule, we are unsubscribed
                return Subscriptions.unsubscribed();
            }

            ScheduledAction s = threadWorker.scheduleActual(new Action0() {
                @Override
                public void call() {
                    if (isUnsubscribed()) {
                        return;
                    }
                    action.call();
                }
            }, delayTime, unit);
            innerSubscription.add(s);
            s.addParent(innerSubscription);
            return s;
        }
    }

    static final class CachedWorkerPool {
        private final ThreadFactory threadFactory;
        private final long keepAliveTime;

        CachedWorkerPool(final ThreadFactory threadFactory, long keepAliveTime, TimeUnit unit) {
            this.threadFactory = threadFactory;
            this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
            ...
            ...
        }
        ThreadWorker get() {
            if (allWorkers.isUnsubscribed()) {
                return SHUTDOWN_THREADWORKER;
            }
            while (!expiringWorkerQueue.isEmpty()) {
                ThreadWorker threadWorker = expiringWorkerQueue.poll();
                if (threadWorker != null) {
                    return threadWorker;
                }
            }

            // No cached worker found, so create a new one.
            ThreadWorker w = new ThreadWorker(threadFactory);
            allWorkers.add(w);
            return w;
        }
    }

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

}

第9、10行分别给两个成员变量赋值。

别忘了第2段代码中的Worker是由Scheduler的createWorker()方法创建的，所以看一下第25行的createWorker()方法，pool.get()获取到的是pool指定的泛型CachedWorkerPool，将它传入EventLoopWorker的构造方法，在第38行调用了get()方法跳转到第99行，之后在第111行用刚才的threadFactory构造了ThreadWorker，于是在第121行进入父类NewThreadWorker的构造方法，该父类如下：

//第7段代码
//rx.internal.schedulers.NewThreadWorker 只拷贝了相关核心代码
public class NewThreadWorker extends Scheduler.Worker implements Subscription {
    private final ScheduledExecutorService executor;

    public NewThreadWorker(ThreadFactory threadFactory) {
        ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, threadFactory);
        // Java 7+: cancelled future tasks can be removed from the executor thus avoiding memory leak
        boolean cancelSupported = tryEnableCancelPolicy(exec);
        if (!cancelSupported && exec instanceof ScheduledThreadPoolExecutor) {
            registerExecutor((ScheduledThreadPoolExecutor)exec);
        }
        executor = exec;
    }

    public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
        Action0 decoratedAction = RxJavaHooks.onScheduledAction(action);
        ScheduledAction run = new ScheduledAction(decoratedAction);
        Future f;
        if (delayTime <= 0) {
            f = executor.submit(run);
        } else {
            f = executor.schedule(run, delayTime, unit);
        }
        run.add(f);

        return run;
    }
}

第7行使用Executors创建了一个线程池，传入了两个参数：核心线程数1、之前分析的带有前缀“RxIoScheduler-“的ThreadFactory。最大线程数为Integer.MAX_VALUE，非核心线程保留10ms。

第2段代码的Worker会调用schedule方法，所以再回到第6段代码的68行，之后在第74行调用了ThreadWorker的scheduleActual()方法，于是跳转到第7段代码的第16行。第17行对action进行了包装，第18行将包装后的action转换成ScheduledAction对象，这是一个Runnable对象，所以第21行可以将它作为executor.submit()方法的参数，这个executor就是刚才创建的线程池。

之后线程池将会新开线程，并调用ScheduledAction的run()方法，继续跟进：

//第8段代码
//rx.internal.schedulers.ScheduledAction 只拷贝了相关核心代码
public final class ScheduledAction extends AtomicReference<Thread> implements Runnable, Subscription {
    final SubscriptionList cancel;
    final Action0 action;

    public ScheduledAction(Action0 action) {
        this.action = action;
        this.cancel = new SubscriptionList();
    }

    @Override
    public void run() {
        try {
            lazySet(Thread.currentThread());
            action.call();
        } catch (OnErrorNotImplementedException e) {
            signalError(new IllegalStateException("Exception thrown on Scheduler.Worker thread. Add `onError` handling.", e));
        } catch (Throwable e) {
            signalError(new IllegalStateException("Fatal Exception thrown on Scheduler.Worker thread.", e));
        } finally {
            unsubscribe();
        }
    }

}

第16行的action就是刚才包装后的decoratedAction，所以跳转到第6段代码的第76行，之后在第80行又回调call()方法，跳转到第2段代码的第20行，接着就是之前分析过的 “回调上游Observable的onSubscribe的call()方法”。

至此，第2段代码就已经打通了，子线程也已经开始运行。

我们对subscribeOn()的总结再加以完善：

  1. 该方法返回了一个新的Observable
  2. 新的Observable收到订阅回调后， 创建了一个核心线程数为1，最大线程数为Integer.MAX_VALUE的线程池，新线程名的前缀为 “RxIoScheduler-“，之后的代码将运行在新线程中，直到遇到线程切换。
  3. 通过层层回调，最终回调了上游Observable的onSubscribe的call()方法。
  4. 新的Observable中的OnSubscribe的call回调中新建的Subscriber接收到事件后，继续将事件传递给下游的Subscriber。
  5. 该方法改变的是上游回调call()方法执行时所处的线程，当使用多个 subscribeOn() 时，只有第一个subscribeOn() 决定事件发送时的线程。

observeOn()

现在我们看一下observeOn(AndroidSchedulers.mainThread())这行代码实现的原理：

//第9段代码
public final Observable observeOn(Scheduler scheduler) {
    return observeOn(scheduler, RxRingBuffer.SIZE);
}

public final Observable observeOn(Scheduler scheduler, int bufferSize) {
    return observeOn(scheduler, false, bufferSize);
}

public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        if (this instanceof ScalarSynchronousObservable) {
            return ((ScalarSynchronousObservable)this).scalarScheduleOn(scheduler);
        }
        return lift(new OperatorObserveOn(scheduler, delayError, bufferSize));
}

public final  Observable lift(final Operatorsuper T> operator) {
        return create(new OnSubscribeLift(onSubscribe, operator));
}

经过两个方法的调用，在第14行出现了新的对象OperatorObserveOn，先不管它，继续看主逻辑。

第18行又是我们熟悉的create()方法，不用多说，它的参数是个OnSubscribe接口对象，跟进OnSubscribeLift：

//第10段代码
public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {

    final OnSubscribe parent;

    final Operator extends R, ? super T> operator;

    public OnSubscribeLift(OnSubscribe parent, Operator extends R, ? super T> operator) {
        this.parent = parent;
        this.operator = operator;
    }

    @Override
    public void call(Subscriber super R> o) {
        try {
            Subscriber super T> st = RxJavaHooks.onObservableLift(operator).call(o);
            try {
                st.onStart();
                parent.call(st);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                st.onError(e);
            }
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            o.onError(e);
        }
    }
}

这个类代码不多，比较简单。第16行新建了一个Subscriber对象，紧接着又是熟悉的操作：调用这个新Subscriber对象的onStart()方法、回调上游OnSubscribe的call()方法。

很明显，这里收到订阅回调后没有发生线程切换，也没有其他多余的操作。

那这个新的Subscriber对象接收到事件后，又发生了什么呢？

根据第16行，我们要看第9段代码第14行OperatorObserveOn的call()方法来了解这个新的Subscriber对象了：

//第11段代码
//rx.internal.operators.OperatorObserveOn 只拷贝了相关核心代码
public final class OperatorObserveOn<T> implements Operator<T, T> {

    public OperatorObserveOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        this.scheduler = scheduler;
        this.delayError = delayError;
        this.bufferSize = (bufferSize > 0) ? bufferSize : RxRingBuffer.SIZE;
    }

    @Override
    public Subscribersuper T> call(Subscribersuper T> child) {
        if (scheduler instanceof ImmediateScheduler) {
            // avoid overhead, execute directly
            return child;
        } else if (scheduler instanceof TrampolineScheduler) {
            // avoid overhead, execute directly
            return child;
        } else {
            ObserveOnSubscriber parent = new ObserveOnSubscriber(scheduler, child, delayError, bufferSize);
            parent.init();
            return parent;
        }
    }

    static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Action0 {
        public ObserveOnSubscriber(Scheduler scheduler, Subscribersuper T> child, boolean delayError, int bufferSize) {
            this.child = child;
            this.recursiveScheduler = scheduler.createWorker();
            this.delayError = delayError;
            ...
            ...
        }

        @Override
        public void onNext(final T t) {
            if (isUnsubscribed() || finished) {
                return;
            }
            if (!queue.offer(NotificationLite.next(t))) {
                onError(new MissingBackpressureException());
                return;
            }
            schedule();
        }

        @Override
        public void onCompleted() {
            if (isUnsubscribed() || finished) {
                return;
            }
            finished = true;
            schedule();
        }

        @Override
        public void onError(final Throwable e) {
            if (isUnsubscribed() || finished) {
                RxJavaHooks.onError(e);
                return;
            }
            error = e;
            finished = true;
            schedule();
        }

        protected void schedule() {
            if (counter.getAndIncrement() == 0) {
                recursiveScheduler.schedule(this);
            }
        }
    }
}

进入第12行的call()方法，因为我们使用的是AndroidSchedulers.mainThread()，所以就直接到了第20行。这里将ObserveOnSubscriber作为Subscriber返回，所以再看这个对象的onNext()等方法就知道如何处理事件了。

第40行将当前接收到的事件保存进了队列queue，先记住这点，后面就会用到了。

第44、53、64行都调用了schedule()这个方法。注意：onCompleted()和onError方法中都将标志位finished设为了true。

第69行调用了recursiveScheduler的schedule()方法，recursiveScheduler是在第20行跳到29行赋值的，我们需要找到AndroidSchedulers.mainThread()的createWorker()方法，先找到AndroidSchedulers.mainThread()：

//第12段代码
//rx.android.schedulers.AndroidSchedulers 只拷贝了相关核心代码
public final class AndroidSchedulers {
    private final Scheduler mainThreadScheduler;

    private AndroidSchedulers() {
        RxAndroidSchedulersHook hook = RxAndroidPlugins.getInstance().getSchedulersHook();

        Scheduler main = hook.getMainThreadScheduler();
        if (main != null) {
            mainThreadScheduler = main;
        } else {
            mainThreadScheduler = new LooperScheduler(Looper.getMainLooper());
        }
    }
}

第13行用主线程的Looper构建了LooperScheduler，继续跟进：

//第13段代码
//rx.android.schedulers.Scheduler 
class LooperScheduler extends Scheduler {
    private final Handler handler;

    LooperScheduler(Looper looper) {
        handler = new Handler(looper);
    }

    @Override
    public Worker createWorker() {
        return new HandlerWorker(handler);
    }

    static class HandlerWorker extends Worker {

        @Override
        public Subscription schedule(final Action0 action) {
            return schedule(action, 0, TimeUnit.MILLISECONDS);
        }

        @Override
        public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
            if (unsubscribed) {
                return Subscriptions.unsubscribed();
            }

            action = hook.onSchedule(action);

            ScheduledAction scheduledAction = new ScheduledAction(action, handler);

            Message message = Message.obtain(handler, scheduledAction);
            message.obj = this; // Used as token for unsubscription operation.

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

            if (unsubscribed) {
                handler.removeCallbacks(scheduledAction);
                return Subscriptions.unsubscribed();
            }

            return scheduledAction;
        }
    }

    static final class ScheduledAction implements Runnable, Subscription {
        ScheduledAction(Action0 action, Handler handler) {
            this.action = action;
            this.handler = handler;
        }

         @Override
         public void run() {
            try {
                action.call();
            } catch (Throwable e) {
              ...
            }
        }
    }
}

第12行又用主线程的Looper构建了HandlerWorker，所以只要看HandlerWorker的schedule()方法就行了。

第35行向主线程的消息队列发送了一条消息，这条消息将被主线程的Looper取出，到时候第30行scheduledAction的回调run()方法就会在主线程执行了，这就实现了切换回主线程的目的。

再看第53行，run()方法里又回调了action的call()方法，即第11段代码第26行类ObserveOnSubscriber所实现的方法，如下：

@Override
public void call() {
    long missed = 1L;
    long currentEmission = emitted;
    final Queue q = this.queue;
    final Subscribersuper T> localChild = this.child;
    for (;;) {
        long requestAmount = requested.get();

        while (requestAmount != currentEmission) {
            boolean done = finished;
            Object v = q.poll();
            boolean empty = v == null;

            if (checkTerminated(done, empty, localChild, q)) {
                return;
            }

            if (empty) {
                break;
            }

            localChild.onNext(NotificationLite.getValue(v));

            currentEmission++;
            if (currentEmission == limit) {
                requestAmount = BackpressureUtils.produced(requested, currentEmission);
                request(currentEmission);
                currentEmission = 0L;
            }
        }

        if (requestAmount == currentEmission) {
            if (checkTerminated(finished, q.isEmpty(), localChild, q)) {
                return;
            }
        }

        emitted = currentEmission;
        missed = counter.addAndGet(-missed);
        if (missed == 0L) {
            break;
        }
    }
}
 
  
第6行的localChild就是下游Subscriber，这从第11代码中不难发现。
 
  
第12行取出了之前保存在队列queue中的事件，第23行调用了下游Subscriber的onNext()方法，事件继续向下传递，而这一切都发生在主线程中。
 
  
至此，对observeOn()方法可以有如下总结：
 
  
     
   
  1. 该方法返回了一个新的Observable
    2.  
   
  2. 新的Observable收到订阅回调后，回调了上游Observable的onSubscribe的call()方法。
    3.  
   
  3. 新的Observable中的OnSubscribe的call回调中新建的Subscriber接收到事件后，将事件包装后发送到主线程的消息队列。
    4.  
   
  4. 在主线程中，事件继续向下游Subscriber传递。
    5.  
   
  5. 该方法改变的是下游订阅者方法执行时所处的线程，可以通过多次调用observeOn()方法，实现下游订阅者在多个线程间切换执行。
    6.  
  
 
  
线程调度总结
 
  
以上对两种线程调度操作符都做了详细的分析和总结，切换线程时一个利用线程池，一个利用主线程Looper消息机制。
 
  
再配合下面这幅流程图食用，消化更佳~
 
  
这幅图来自于扔物线的给 Android 开发者的 RxJava 详解，因为这幅图总结地很好，和本文分析的结论也是完全一致，所以就直接拿来用了。
 
  
【源码分析】RxJava 1.2.2 实现简单事件流的原理_第1张图片
 
  
相信理解完本文内容，大家对RxJava 1.x应该有了较好的认识，当然它的其他实现原理也很值得我们再深入研究。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Android源码分析,RxJava,线程调度,原理,线程池,消息机制)

        

            

                
    
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • git - Webhook让部署自动化
                        大猪大猪

                        
    我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • Faiss：高效相似性搜索与聚类的利器
                        网络·魚
大数据faiss
                        
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
    
                    
    • 
                    
  • ES聚合分析原理与代码实例讲解
                        光剑书架上的书
大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
                        
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
    
                    
    • 
                    
  • 2022-08-28
                        蔚蓝一片晴

                        
    初三暑假培训收获点滴从8月25至8月27日三天两晚的培训结束了，回到家中，该静下心来整理一下触动心灵的收获，成为成长的积淀。1.在优秀团队中快速成长与提升，做一名反思成长型教师一名专业型教师的教学指导包括了教学原理知识、案例知识、策略知识。面对教学中的遇到的有趣的情形、问题会去研究其理，寻找更好的教法学法对策。从新手到成熟型教师，再走向专业型教师，需要的是觉醒与反思，多进行案例研究，从案例中观察、
    
                    
    • 
                    
  • STM32中的计时与延时
                        lupinjia
STM32stm32单片机
                        
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
    
                    
    • 
                    
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通
                        学习3人组
大数据大数据
                        
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
    
                    
    • 
                    
  • 5分钟说透AppStore审核原理，让你拥有上架新思路！
                        Q仔本人噢

                        
    在AppStore上架是越来越难了!相信非常多公司的技术人员都为此困扰，然而外包团队水平又层次不齐，容易遇坑，实在是内忧外患。是什么原因导致审核机制频繁调整？又是什么原因使得审核变得越发严格？那么接下来听小Q分解，马上给各位带来解答!首先看一下近一年的上下架的情况：近一年上架情况近一年下架情况通过数据我们发现越是马甲包产量权重高的分类里被下架的app数量越多，苹果此举可谓是上有政策，下有对策。通过
    
                    
    • 
                    
  • 2019-03-24
                        李飞720

                        
    姓名：李飞企业名称：临沂鑫道食品有限公司组别373期利他1组日精进打卡第338天】【知~学习】1、阿米巴经营一段2、活用人才1段3、活法、一段【行~实践】一、修身：读书、抽烟减量、俯卧撑个跑步3公里二、齐家、劝说老爸与姑姑和好三、建功、业务洽谈【经典名句分享】1、依据原理原则追求事物的本质，以“作为人，何谓正确”进行判断2、经营者必须为员工物质和精神两方面的幸福殚精竭虑，倾尽全力，必须超脱私心，让
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • 计算机木马详细编写思路
                        小熊同学哦
php开发语言木马木马思路
                        
    导语：计算机木马（ComputerTrojan）是一种恶意软件，通过欺骗用户从而获取系统控制权限，给黑客打开系统后门的一种手段。虽然木马的存在给用户和系统带来严重的安全风险，但是了解它的工作原理与编写思路，对于我们提高防范意识、构建更健壮的网络安全体系具有重要意义。本篇博客将深入剖析计算机木马的详细编写思路，以及如何复杂化挑战，以期提高读者对计算机木马的认识和对抗能力。计算机木马的基本原理计算机木
    
                    
    • 
                    
  • 在RabbitMQ中四种常见的消息路由模式
                        Xwzzz_
rabbitmq分布式
                        
    1.Fanout模式Fanout模式的交换机是扇出交换机（FanoutExchange），它会将消息广播给所有绑定到它的队列，而不考虑消息的内容或路由键。工作原理：生产者发送消息到FanoutExchange。FanoutExchange会将消息广播给所有绑定到它的队列，所有绑定的队列都会收到这条消息。消费者监听绑定的队列，处理收到的消息。特点：没有路由键：消息不需要路由键，所有绑定的队列都会接收
    
                    
    • 
                    
  • C++八股
                        Petrichorzncu
八股总结c++开发语言
                        
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现
                        Lenyiin
C++修炼全景指南技术指南c++数据结构stl
                        
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
    
                    
    • 
                    
  • 非对称加密算法原理与应用2——RSA私钥加密文件
                        私语茶馆
云部署与开发架构及产品灵感记录RSA2048私钥加密
                        
    作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
    
                    
    • 
                    
  • 为什么学生不喜欢上学
                        虾虾说

                        
    图片发自App《为什么学生不喜欢上学》作者是丹尼尔·威林厄姆。本书从认知心理学角度，结合大量实证案例，阐释了大脑工作的基本原理，回答了关于学习过程的一系列问题。为什么学生不喜欢上学？——大脑工作的基本原理思考是缓慢的、费力的、不可靠的。思考有三个要素，环境、工作记忆和长期记忆。环境是信息来源；长期记忆是知识、经验的巨型仓库，随时可以调取；工作记忆是中央处理器，是加工信息素材的中央厨房，也是思考过程
    
                    
    • 
                    
  • 补充元象二面
                        Redstone Monstrosity
前端面试
                        
    1.请尽可能详细地说明，防抖和节流的区别，应用场景？你的回答中不要写出示例代码。防抖（Debounce）和节流（Throttle）是两种常用的前端性能优化技术，它们的主要区别在于如何处理高频事件的触发。以下是防抖和节流的区别和应用场景的详细说明：防抖和节流的定义防抖：在一段时间内，多次执行变为只执行最后一次。防抖的原理是，当事件被触发后，设置一个延迟定时器。如果在这个延迟时间内事件再次被触发，则重
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表
                        Lenyiin
技术指南C++修炼全景指南c++list链表stl
                        
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
    
                    
    • 
                    
  • AI大模型的架构演进与最新发展
                        季风泯灭的季节
AI大模型应用技术二人工智能架构
                        
    随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
    
                    
    • 
                    
  • [实践应用] 深度学习之优化器
                        YuanDaima2048
深度学习工具使用pytorch深度学习人工智能机器学习python优化器
                        
    文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
    
                    
    • 
                    
  • 【高阶数据结构】并查集
                        椿融雪
数据结构与算法数据结构并查集
                        
    文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
    
                    
    • 
                    
  • 《HTML 与 CSS—— 响应式设计》
                        陈在天box
htmlcss前端
                        
    一、引言在当今数字化时代，人们使用各种不同的设备访问互联网，包括智能手机、平板电脑、笔记本电脑和台式机等。为了确保网站在不同设备上都能提供良好的用户体验，响应式设计成为了网页开发的关键。HTML和CSS作为网页开发的基础技术，在实现响应式设计方面发挥着重要作用。本文将深入探讨HTML与CSS中的响应式设计原理、方法和最佳实践。二、响应式设计的概念与重要性（一）概念响应式设计是一种网页设计方法，旨在
    
                    
    • 
                    
  • KVM虚拟机源代码分析【转】
                        xidianjiapei001
#虚拟化技术
                        
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
    
                    
    • 
                    
  • 嵌入式单片机中数码管基本实现方法
                        嵌入式开发星球
单片机项目实战操作之优秀单片机
                        
    1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
    
                    
    • 
                    
  • 360前端星计划-动画可以这么玩
                        马小蜗

                        
    动画的基本原理定时器改变对象的属性根据新的属性重新渲染动画functionupdate(context){//更新属性}constticker=newTicker();ticker.tick(update,context);动画的种类1、JavaScript动画操作DOMCanvas2、CSS动画transitionanimation3、SVG动画SMILJS动画的优缺点优点：灵活度、可控性、性能
    
                    
    • 
                    
  • 俞军关于企业本质的读书思考
                        小廖BOY

                        
    本文内容来自于俞军老师的聊天记录关于企业本质的一点思考总体上，企业的本质，只在于两点：1.发现市场获利机会。2.生产效率高于市场。一、发现市场获利机会发现市场获利机会的路径有三种：洞察，其实是利用信息不对称获利。你知道哪里能买到便宜生产要素，你知道哪些用户更想要什么，你精通一种有用的新技术新方法新渠道，你知道什么约束条件将会变化，而别人不知道，这里就都有市场获利机会。试错，其实是因为信息不完全原理
    
                    
    • 
                                
  • 解线性方程组
                                    qiuwanchi

                                    
    package gaodai.matrix;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Test {

	public static void main(String[] args) {
		Scanner scanner = new Sc
    
                                
    • 
                                
  • 在mysql内部存储代码
                                    annan211
性能mysql存储过程触发器
                                    
    

在mysql内部存储代码
  在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。
  先看优点：
  1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。
  2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。
  3 可以简化代码的维护和版本更新。
  4 可以帮助提升安全，比如提供更细
    
                                
    • 
                                
  • Android使用Asynchronous Http Client完成登录保存cookie的问题
                                    hotsunshine
android
                                    
    Asynchronous Http Client是android中非常好的异步请求工具 
除了异步之外还有很多封装比如json的处理，cookie的处理 
 
  引用   
 
Persistent Cookie Storage with PersistentCookieStore 
 
This library also includes a PersistentCookieStore whi
    
                                
    • 
                                
  • java面试题
                                    Array_06
java面试
                                    
    java面试题 
 
 
第一，谈谈final, finally, finalize的区别。 
final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
    
                                
    • 
                                
  • 网站加速
                                    oloz
网站加速
                                    
    前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教. 
 
 
1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。 
 
 
2、采用Gzip对网页进行压缩； 
   GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
    
                                
    • 
                                
  • 正确书写单例模式
                                    随意而生
java 设计模式 单例
                                    
    　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。 
 
　　懒汉式，线程不安全 
 
　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
    
                                
    • 
                                
  • 单例模式
                                    香水浓
java
                                    
    懒汉  调用getInstance方法时实例化 
 

public class Singleton {

	private static Singleton instance;
	
	private Singleton() {}

	public static synchronized Singleton getInstance() {
		if(null == ins
    
                                
    • 
                                
  • 安装Apache问题：系统找不到指定的文件 No installed service named "Apache2"
                                    AdyZhang
apachehttp server
                                    
    安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" 
每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。 
解决方法确保几处： 
1、停止IIS启动 
2、把端口80改成其它 （譬如90，800，，，什么数字都好） 
3、防火墙(关掉试试) 
在运行处输入 cmd 回车，转到apa
    
                                
    • 
                                
  • 如何在android 文件选择器中选择多个图片或者视频？
                                    aijuans
android
                                    
    我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传 
但是android原生态的sdk中，只能一个一个的进行选择和上传。 
我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个   处理方法 
官方的图片选择器(但是不支持所有版本的androi，只支持API Level 
    
                                
    • 
                                
  • mysql中查询生日提醒的日期相关的sql
                                    baalwolf
mysql
                                    
    SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(),  dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
    
                                
    • 
                                
  • MongoDB索引文件破坏后导致查询错误的问题
                                    BigBird2012
mongodb
                                    
    问题描述： 
MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。 
解决方案： 
  
使用脚本，重建MongoDB所有表的索引。 
var names  = db.getCollectionNames();
for( var i in names ){
    var name = names[i];
    print(name);

    
                                
    • 
                                
  • Javascript Promise
                                    bijian1013
JavaScriptPromise
                                    
            Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。 
一.认识Promises 
        “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
    
                                
    • 
                                
  • [Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程
                                    bit1129
zookeeper
                                    
       Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是   
  
public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
    
                                
    • 
                                
  • 【Java命令三】jstack
                                    bit1129
jstack
                                    
    jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump 
  
[hadoop@hadoop sbin]$ jstack
Usage:
    jstack [-l] <pid>
        (to connect to running process)
    jstack -F 
    
                                
    • 
                                
  • jboss 5.1启停脚本　动静分离部署
                                    ronin47

                                    
    以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename  -b ip -g  clustername   -u broatcast jboss.messaging.ServerPeerID=int  -Djboss.service.binding.set=p
    
                                
    • 
                                
  • UI之如何打磨设计能力?
                                    brotherlamp
UIui教程ui自学ui资料ui视频
                                    
      
在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。 
1.找到自己的方式 
如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
    
                                
    • 
                                
  • 三色旗算法
                                    bylijinnan
java算法
                                    
    

import java.util.Arrays;

/**
问题：
假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，
您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳
子上进行这个动作，而且一次只能调换两个旗子。

网上的解法大多类似：
在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
    
                                
    • 
                                
  • 警告:No configuration found for the specified action: \'s
                                    chiangfai
configuration
                                    
    1.index.jsp页面form标签未指定namespace属性。 
<!--index.jsp代码--> 
 
<%@taglib prefix="s" uri="/struts-tags"%>
...
<s:form action="submit" method="post"&g
    
                                
    • 
                                
  • redis -- hash_max_zipmap_entries设置过大有问题
                                    chenchao051
redishash
                                    
    使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑 
  
#define ZIPMAP_BIGLEN 254
#define ZIPMAP_END 255 
  
  
/* Return th
    
                                
    • 
                                
  • select into outfile access deny问题
                                    daizj
mysqltxt导出数据到文件
                                    
    本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/ 
 
为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。 
授权的语句如下： 
grant select on armory.* to rn
    
                                
    • 
                                
  • phpexcel导出excel表简单入门示例
                                    dcj3sjt126com
PHPExcelphpexcel
                                    
      
<?php 
error_reporting(E_ALL); 
ini_set('display_errors', TRUE); 
ini_set('display_startup_errors', TRUE); 
  
if (PHP_SAPI == 'cli') 
 die('This example should only be run from a Web Brows
    
                                
    • 
                                
  • 美国电影超短200句
                                    dcj3sjt126com
电影
                                    
    1. I see． 我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too． 我也是。5. My god! 天哪!6. No way! 不行!7. Come on． 来吧(赶快)8. Hold on． 等一等。9. I agree。 我同意。10. Not bad． 还不错。11. Not yet． 还没。12. See you． 再见。13. Shut up! 
    
                                
    • 
                                
  • Java访问远程服务
                                    dyy_gusi
httpclientwebservicegetpost
                                    
        随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
    
                                
    • 
                                
  • Maven的settings.xml配置
                                    geeksun
settings.xml
                                    
    settings.xml是Maven的配置文件，下面解释一下其中的配置含义： 
settings.xml存在于两个地方： 
1.安装的地方：$M2_HOME/conf/settings.xml 
2.用户的目录：${user.home}/.m2/settings.xml 
前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。 

    
                                
    • 
                                
  • ubuntu的init与系统服务设置
                                    hongtoushizi
ubuntu
                                    
    转载自： 
http://iysm.net/?p=178  init 
Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。 
ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。  
运行
    
                                
    • 
                                
  • 跟我学Nginx+Lua开发目录贴
                                    jinnianshilongnian
nginxlua
                                    
    使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。  
  目录 
第一章 安装Nginx+Lua开发环境 
第二章 Nginx+Lua开发入门 
第三章 Redis/SSDB+Twemproxy安装与使用 
第四章 L
    
                                
    • 
                                
  • php位运算符注意事项
                                    home198979
位运算PHP&
                                    
    $a = $b = $c = 0;
$a & $b = 1;
$b | $c = 1 
 问a,b,c最终为多少? 
  
当看到这题时，我犯了一个低级错误，误 以为位运算符会改变变量的值。所以得出结果是1 1 0 
但是位运算符是不会改变变量的值的，例如： 
$a=1;$b=2;
$a&$b;
 
 这样a,b的值不会有任何改变 

    
                                
    • 
                                
  • Linux shell数组建立和使用技巧
                                    pda158
linux
                                    
    1.数组定义   　　[chengmo@centos5 ~]$ a=(1 2 3 4 5)   　　[chengmo@centos5 ~]$ echo $a   　　1   　　一对括号表示是数组，数组元素用“空格”符号分割开。   　　 
2.数组读取与赋值   　　得到长度：   　　[chengmo@centos5 ~]$ echo ${#a[@]}   　　5   　　用${#数组名[@或
    
                                
    • 
                                
  • hotspot源码(JDK7)
                                    ol_beta
javaHotSpotjvm
                                    
    源码结构图，方便理解： 
  
├─agent                            Serviceab
    
                                
    • 
                                
  • Oracle基本事务和ForAll执行批量DML练习
                                    vipbooks
oraclesql
                                    
    基本事务的使用： 
从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚 
 
 

select * from account;
-- 创建一张账户表
create table account(
       -- 账户ID
       id number(3) not null,
       -- 账户名称
       nam
    
                                
    •