香沙小熊
香沙小熊

响应式编程RxJava（二）

PublishSubject 源码分析

/**
 * Copyright 2014 Netflix, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package rx.subjects;

import java.util.*;
import java.util.concurrent.atomic.*;

import rx.*;
import rx.Observer;
import rx.exceptions.*;
import rx.internal.operators.BackpressureUtils;

/**
 * Subject that, once an {@link Observer} has subscribed, emits all subsequently observed items to the
 * subscriber.
 * 

 * 
 * 

 * Example usage:
 * 

 * 
 {@code

  PublishSubject subject = PublishSubject.create();
  // observer1 will receive all onNext and onCompleted events
  subject.subscribe(observer1);
  subject.onNext("one");
  subject.onNext("two");
  // observer2 will only receive "three" and onCompleted
  subject.subscribe(observer2);
  subject.onNext("three");
  subject.onCompleted();

  } 
 *
 * @param 
 *          the type of items observed and emitted by the Subject
 */
public final class PublishSubject extends Subject {

    final PublishSubjectState state;

    /**
     * Creates and returns a new {@code PublishSubject}.
     *
     * @param  the value type
     * @return the new {@code PublishSubject}
     */
    public static  PublishSubject create() {
        return new PublishSubject(new PublishSubjectState());
    }

    protected PublishSubject(PublishSubjectState state) {
        super(state);
        this.state = state;
    }

    @Override
    public void onNext(T v) {
        state.onNext(v);
    }

    @Override
    public void onError(Throwable e) {
        state.onError(e);
    }

    @Override
    public void onCompleted() {
        state.onCompleted();
    }


    @Override
    public boolean hasObservers() {
        return state.get().length != 0;
    }

    /**
     * Check if the Subject has terminated with an exception.
     * @return true if the subject has received a throwable through {@code onError}.
     * @since 1.2
     */
    public boolean hasThrowable() {
        return state.get() == PublishSubjectState.TERMINATED && state.error != null;
    }
    /**
     * Check if the Subject has terminated normally.
     * @return true if the subject completed normally via {@code onCompleted}
     * @since 1.2
     */
    public boolean hasCompleted() {
        return state.get() == PublishSubjectState.TERMINATED && state.error == null;
    }
    /**
     * Returns the Throwable that terminated the Subject.
     * @return the Throwable that terminated the Subject or {@code null} if the
     * subject hasn't terminated yet or it terminated normally.
     * @since 1.2
     */
    public Throwable getThrowable() {
        if (state.get() == PublishSubjectState.TERMINATED) {
            return state.error;
        }
        return null;
    }

    static final class PublishSubjectState
    extends AtomicReference[]>
    implements OnSubscribe, Observer {

        /** */
        private static final long serialVersionUID = -7568940796666027140L;

        @SuppressWarnings("rawtypes")
        static final PublishSubjectProducer[] EMPTY = new PublishSubjectProducer[0];
        @SuppressWarnings("rawtypes")
        static final PublishSubjectProducer[] TERMINATED = new PublishSubjectProducer[0];

        Throwable error;

        @SuppressWarnings("unchecked")
        public PublishSubjectState() {
            lazySet(EMPTY);
        }

        @Override
        public void call(Subscriber t) {
            PublishSubjectProducer pp = new PublishSubjectProducer(this, t);
            t.add(pp);
            t.setProducer(pp);

            if (add(pp)) {
                if (pp.isUnsubscribed()) {
                    remove(pp);
                }
            } else {
                Throwable ex = error;
                if (ex != null) {
                    t.onError(ex);
                } else {
                    t.onCompleted();
                }
            }
        }


        boolean add(PublishSubjectProducer inner) {
            for (;;) {
                PublishSubjectProducer[] curr = get();
                if (curr == TERMINATED) {
                    return false;
                }

                int n = curr.length;

                @SuppressWarnings("unchecked")
                PublishSubjectProducer[] next = new PublishSubjectProducer[n + 1];
                System.arraycopy(curr, 0, next, 0, n);

                next[n] = inner;
                if (compareAndSet(curr, next)) {
                    return true;
                }
            }
        }

        @SuppressWarnings("unchecked")
        void remove(PublishSubjectProducer inner) {
            for (;;) {
                PublishSubjectProducer[] curr = get();
                if (curr == TERMINATED || curr == EMPTY) {
                    return;
                }

                int n = curr.length;
                int j = -1;
                for (int i = 0; i < n; i++) {
                    if (curr[i] == inner) {
                        j = i;
                        break;
                    }
                }

                if (j < 0) {
                    return;
                }

                PublishSubjectProducer[] next;
                if (n == 1) {
                    next = EMPTY;
                } else {
                    next = new PublishSubjectProducer[n - 1];
                    System.arraycopy(curr, 0, next, 0, j);
                    System.arraycopy(curr, j + 1, next, j, n - j - 1);
                }

                if (compareAndSet(curr, next)) {
                    return;
                }
            }
        }

        @Override
        public void onNext(T t) {
            for (PublishSubjectProducer pp : get()) {
                pp.onNext(t);
            }
        }

        @SuppressWarnings("unchecked")
        @Override
        public void onError(Throwable e) {
            error = e;
            List errors = null;
            for (PublishSubjectProducer pp : getAndSet(TERMINATED)) {
                try {
                    pp.onError(e);
                } catch (Throwable ex) {
                    if (errors == null) {
                        errors = new ArrayList(1);
                    }
                    errors.add(ex);
                }
            }

            Exceptions.throwIfAny(errors);
        }

        @SuppressWarnings("unchecked")
        @Override
        public void onCompleted() {
            for (PublishSubjectProducer pp : getAndSet(TERMINATED)) {
                pp.onCompleted();
            }
        }

    }

    static final class PublishSubjectProducer
    extends AtomicLong
    implements Producer, Subscription, Observer {
        /** */
        private static final long serialVersionUID = 6451806817170721536L;

        final PublishSubjectState parent;

        final Subscriber actual;

        long produced;

        public PublishSubjectProducer(PublishSubjectState parent, Subscriber actual) {
            this.parent = parent;
            this.actual = actual;
        }

        @Override
        public void request(long n) {
            if (BackpressureUtils.validate(n)) {
                for (;;) {
                    long r = get();
                    if (r == Long.MIN_VALUE) {
                        return;
                    }
                    long u = BackpressureUtils.addCap(r, n);
                    if (compareAndSet(r, u)) {
                        return;
                    }
                }
            }
        }

        @Override
        public boolean isUnsubscribed() {
            return get() == Long.MIN_VALUE;
        }

        @Override
        public void unsubscribe() {
            if (getAndSet(Long.MIN_VALUE) != Long.MIN_VALUE) {
                parent.remove(this);
            }
        }

        @Override
        public void onNext(T t) {
            long r = get();
            if (r != Long.MIN_VALUE) {
                long p = produced;
                if (r != p) {
                    produced = p + 1;
                    actual.onNext(t);
                } else {
                    unsubscribe();
                    actual.onError(new MissingBackpressureException("PublishSubject: could not emit value due to lack of requests"));
                }
            }
        }

        @Override
        public void onError(Throwable e) {
            if (get() != Long.MIN_VALUE) {
                actual.onError(e);
            }
        }

        @Override
        public void onCompleted() {
            if (get() != Long.MIN_VALUE) {
                actual.onCompleted();
            }
        }
    }
}



第一步：创建Observable：PublishSubject.create()；


第二步：在PublishSubject类的Create()方法中，创建了观察者管理器PublishSubjectProducer


第三步：在PublishSubject的create方法中创建了new PublishSubject(state,state)对象，并将管理器传入


第四步：在PublishSubject的.call方法中创建了new PublishSubject(state,state)对象，并将管理器传入
 第五步：在call()方法中创建了new PublishSubject(state,state)对象，并将管理器传入


BehaviorSubject 使用


  private BehaviorSubject behaviorSubject;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple2);
        //我默认发送一条消息，以后都是正常
        behaviorSubject = BehaviorSubject.create("发送默认消息");
    }

    public void click(View v) {
        behaviorSubject.subscribe(new Observer() {
            @Override
            public void onCompleted() {
                Log.i("main", "完成......");
            }

            @Override
            public void onError(Throwable e) {
                Log.i("main", "异常......");
            }

            @Override
            public void onNext(String message) {
                Log.i("main", "消息：" + message);
            }
        });

    }

    public void send(View v) {
        behaviorSubject.onNext("你好，要坚持住.....");
    }

结果输出：
08-03 10:26:07.037 18544-18544/com.haocai.architect.rxjava I/main: 消息：发送默认消息




BehaviorSubject 源码


public final class BehaviorSubject extends Subject {
    /** An empty array to trigger getValues() to return a new array. */
    private static final Object[] EMPTY_ARRAY = new Object[0];
    private final SubjectSubscriptionManager state;

    /**
     * Creates a {@link BehaviorSubject} without a default item.
     *
     * @param 
     *            the type of item the Subject will emit
     * @return the constructed {@link BehaviorSubject}
     */
    public static  BehaviorSubject create() {
        return create(null, false);
    }
    /**
     * Creates a {@link BehaviorSubject} that emits the last item it observed and all subsequent items to each
     * {@link Observer} that subscribes to it.
     *
     * @param 
     *            the type of item the Subject will emit
     * @param defaultValue
     *            the item that will be emitted first to any {@link Observer} as long as the
     *            {@link BehaviorSubject} has not yet observed any items from its source {@code Observable}
     * @return the constructed {@link BehaviorSubject}
     */
    public static  BehaviorSubject create(T defaultValue) {
        return create(defaultValue, true);
    }
    private static  BehaviorSubject create(T defaultValue, boolean hasDefault) {
        final SubjectSubscriptionManager state = new SubjectSubscriptionManager();
        if (hasDefault) {
            state.setLatest(NotificationLite.next(defaultValue));
        }
        state.onAdded = new Action1>() {

            @Override
            public void call(SubjectObserver o) {
                o.emitFirst(state.getLatest());
            }

        };
        state.onTerminated = state.onAdded;
        return new BehaviorSubject(state, state);
    }

    protected BehaviorSubject(OnSubscribe onSubscribe, SubjectSubscriptionManager state) {
        super(onSubscribe);
        this.state = state;
    }

    @Override
    public void onCompleted() {
        Object last = state.getLatest();
        if (last == null || state.active) {
            Object n = NotificationLite.completed();
            for (SubjectObserver bo : state.terminate(n)) {
                bo.emitNext(n);
            }
        }
    }

    @Override
    public void onError(Throwable e) {
        Object last = state.getLatest();
        if (last == null || state.active) {
            Object n = NotificationLite.error(e);
            List errors = null;
            for (SubjectObserver bo : state.terminate(n)) {
                try {
                    bo.emitNext(n);
                } catch (Throwable e2) {
                    if (errors == null) {
                        errors = new ArrayList();
                    }
                    errors.add(e2);
                }
            }

            Exceptions.throwIfAny(errors);
        }
    }

    @Override
    public void onNext(T v) {
        Object last = state.getLatest();
        if (last == null || state.active) {
            Object n = NotificationLite.next(v);
            for (SubjectObserver bo : state.next(n)) {
                bo.emitNext(n);
            }
        }
    }

    /* test support */ int subscriberCount() {
        return state.observers().length;
    }

    @Override
    public boolean hasObservers() {
        return state.observers().length > 0;
    }
    /**
     * Check if the Subject has a value.
     * 
Use the {@link #getValue()} method to retrieve such a value.
     * 
Note that unless {@link #hasCompleted()} or {@link #hasThrowable()} returns true, the value
     * retrieved by {@code getValue()} may get outdated.
     * @return true if and only if the subject has some value and hasn't terminated yet.
     * @since 1.2
     */
    public boolean hasValue() {
        Object o = state.getLatest();
        return NotificationLite.isNext(o);
    }
    /**
     * Check if the Subject has terminated with an exception.
     * @return true if the subject has received a throwable through {@code onError}.
     * @since 1.2
     */
    public boolean hasThrowable() {
        Object o = state.getLatest();
        return NotificationLite.isError(o);
    }
    /**
     * Check if the Subject has terminated normally.
     * @return true if the subject completed normally via {@code onCompleted()}
     * @since 1.2
     */
    public boolean hasCompleted() {
        Object o = state.getLatest();
        return NotificationLite.isCompleted(o);
    }
    /**
     * Returns the current value of the Subject if there is such a value and
     * the subject hasn't terminated yet.
     * 
The method can return {@code null} for various reasons. Use {@link #hasValue()}, {@link #hasThrowable()}
     * and {@link #hasCompleted()} to determine if such {@code null} is a valid value, there was an
     * exception or the Subject terminated (with or without receiving any value).
     * @return the current value or {@code null} if the Subject doesn't have a value,
     * has terminated or has an actual {@code null} as a valid value.
     * @since 1.2
     */
    public T getValue() {
        Object o = state.getLatest();
        if (NotificationLite.isNext(o)) {
            return NotificationLite.getValue(o);
        }
        return null;
    }
    /**
     * Returns the Throwable that terminated the Subject.
     * @return the Throwable that terminated the Subject or {@code null} if the
     * subject hasn't terminated yet or it terminated normally.
     * @since 1.2
     */
    public Throwable getThrowable() {
        Object o = state.getLatest();
        if (NotificationLite.isError(o)) {
            return NotificationLite.getError(o);
        }
        return null;
    }
    /**
     * Returns a snapshot of the currently buffered non-terminal events into
     * the provided {@code a} array or creates a new array if it has not enough capacity.
     * @param a the array to fill in
     * @return the array {@code a} if it had enough capacity or a new array containing the available values
     * @since 1.2
     */
    @SuppressWarnings("unchecked")
    public T[] getValues(T[] a) {
        Object o = state.getLatest();
        if (NotificationLite.isNext(o)) {
            if (a.length == 0) {
                a = (T[])Array.newInstance(a.getClass().getComponentType(), 1);
            }
            a[0] = NotificationLite.getValue(o);
            if (a.length > 1) {
                a[1] = null;
            }
        } else
        if (a.length > 0) {
            a[0] = null;
        }
        return a;
    }

    /**
     * Returns a snapshot of the currently buffered non-terminal events.
     * 
The operation is thread-safe.
     *
     * @return a snapshot of the currently buffered non-terminal events.
     * @since (If this graduates from being an Experimental class method, replace this parenthetical with the release number)
     * @since 1.2
     */
    @SuppressWarnings("unchecked")
    public Object[] getValues() {
        T[] r = getValues((T[])EMPTY_ARRAY);
        if (r == EMPTY_ARRAY) {
            return new Object[0]; // don't leak the default empty array.
        }
        return r;
    }
}



ReplaySubject 基本使用


    private ReplaySubject replaySubject;
    private EditText editText;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple2);
        //缓存所有的消息，一旦有新的观察者订阅了，会立马将缓存的所有信息，发送给对应的观察者
        replaySubject = ReplaySubject.create();
    }

    public void click(View v) {
        replaySubject.subscribe(new Observer() {
            @Override
            public void onCompleted() {
                Log.i("main", "完成......");
            }

            @Override
            public void onError(Throwable e) {
                Log.i("main", "异常......");
            }

            @Override
            public void onNext(String message) {
                Log.i("main", "消息：" + message);
            }
        });

    }

    public void send(View v) {
        if(editText==null){
            editText = (EditText) findViewById(R.id.et_text);
        }

        replaySubject.onNext(editText.getText().toString());
    }



AsyncSubject 基本使用


 private AsyncSubject asyncSubject;
    private EditText editText;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple2);
        //总结
        //特点一:我们发送消息的时候，调用了onNext方法，必须还要调用onComplete()方法提交
        //消息才能发送出去，要不然观察者收不到消息
        //特点二:采用了AsyncSubject创建并且添加注册观察者，那么所有的观察者，只会有且只能够收到最近的一条消息

        asyncSubject = AsyncSubject.create();
    }

    public void click(View v) {
        asyncSubject.subscribe(new Observer() {
            @Override
            public void onCompleted() {
                Log.i("main", "完成......");
            }

            @Override
            public void onError(Throwable e) {
                Log.i("main", "异常......");
            }

            @Override
            public void onNext(String message) {
                Log.i("main", "消息：" + message);
            }
        });

    }

    public void send(View v) {
//        if(editText==null){
//            editText = (EditText) findViewById(R.id.et_text);
//        }
        asyncSubject.onNext("hello world");
        asyncSubject.onNext("qwert");
        asyncSubject.onNext("asdfg");
        asyncSubject.onNext("zxcvb");
        asyncSubject.onCompleted();
    }

结果输出：

08-03 14:33:56.457 15968-15968/com.haocai.architect.rxjava I/main: 消息：zxcvb
08-03 14:33:56.457 15968-15968/com.haocai.architect.rxjava I/main: 完成......




AsyncSubject 源码分析


public final class AsyncSubject extends Subject {
    final SubjectSubscriptionManager state;
    volatile Object lastValue;

    /**
     * Creates and returns a new {@code AsyncSubject}.
     * @param  the result value type
     * @return the new {@code AsyncSubject}
     */
    public static  AsyncSubject create() {
        final SubjectSubscriptionManager state = new SubjectSubscriptionManager();
        state.onTerminated = new Action1>() {
            @Override
            public void call(SubjectObserver o) {
                Object v = state.getLatest();
                if (v == null || NotificationLite.isCompleted(v)) {
                    o.onCompleted();
                } else
                if (NotificationLite.isError(v)) {
                    o.onError(NotificationLite.getError(v));
                } else {
                    o.actual.setProducer(new SingleProducer(o.actual, NotificationLite.getValue(v)));
                }
            }
        };
        return new AsyncSubject(state, state);
    }

    protected AsyncSubject(OnSubscribe onSubscribe, SubjectSubscriptionManager state) {
        super(onSubscribe);
        this.state = state;
    }

    @Override
    public void onCompleted() {
        if (state.active) {
            Object last = lastValue;
            if (last == null) {
                last = NotificationLite.completed();
            }
            for (SubjectObserver bo : state.terminate(last)) {
                if (last == NotificationLite.completed()) {
                    bo.onCompleted();
                } else {
                    bo.actual.setProducer(new SingleProducer(bo.actual, NotificationLite.getValue(last)));
                }
            }
        }
    }

    @Override
    public void onError(final Throwable e) {
        if (state.active) {
            Object n = NotificationLite.error(e);
            List errors = null;
            for (SubjectObserver bo : state.terminate(n)) {
                try {
                    bo.onError(e);
                } catch (Throwable e2) {
                    if (errors == null) {
                        errors = new ArrayList();
                    }
                    errors.add(e2);
                }
            }

            Exceptions.throwIfAny(errors);
        }
    }

    @Override
    public void onNext(T v) {
        lastValue = NotificationLite.next(v);
    }

    @Override
    public boolean hasObservers() {
        return state.observers().length > 0;
    }
    /**
     * Check if the Subject has a value.
     * 
Use the {@link #getValue()} method to retrieve such a value.
     * 
Note that unless {@link #hasCompleted()} or {@link #hasThrowable()} returns true, the value
     * retrieved by {@code getValue()} may get outdated.
     * @return true if and only if the subject has some value but not an error
     * @since 1.2
     */
    public boolean hasValue() {
        Object v = lastValue;
        Object o = state.getLatest();
        return !NotificationLite.isError(o) && NotificationLite.isNext(v);
    }
    /**
     * Check if the Subject has terminated with an exception.
     * @return true if the subject has received a throwable through {@code onError}.
     * @since 1.2
     */
    public boolean hasThrowable() {
        Object o = state.getLatest();
        return NotificationLite.isError(o);
    }
    /**
     * Check if the Subject has terminated normally.
     * @return true if the subject completed normally via {@code onCompleted()}
     * @since 1.2
     */
    public boolean hasCompleted() {
        Object o = state.getLatest();
        return o != null && !NotificationLite.isError(o);
    }
    /**
     * Returns the current value of the Subject if there is such a value and
     * the subject hasn't terminated with an exception.
     * 
The method can return {@code null} for various reasons. Use {@link #hasValue()}, {@link #hasThrowable()}
     * and {@link #hasCompleted()} to determine if such {@code null} is a valid value, there was an
     * exception or the Subject terminated without receiving any value.
     * @return the current value or {@code null} if the Subject doesn't have a value,
     * has terminated with an exception or has an actual {@code null} as a value.
     * @since 1.2
     */
    public T getValue() {
        Object v = lastValue;
        Object o = state.getLatest();
        if (!NotificationLite.isError(o) && NotificationLite.isNext(v)) {
            return NotificationLite.getValue(v);
        }
        return null;
    }
    /**
     * Returns the Throwable that terminated the Subject.
     * @return the Throwable that terminated the Subject or {@code null} if the
     * subject hasn't terminated yet or it terminated normally.
     * @since 1.2
     */
    public Throwable getThrowable() {
        Object o = state.getLatest();
        if (NotificationLite.isError(o)) {
            return NotificationLite.getError(o);
        }
        return null;
    }
}



Observable中其他的一些api
 第一个：just()方法


    AppInfo appInfo1 = new AppInfo("Michael同学", 0);
    AppInfo appInfo2 = new AppInfo("Michael同学", 0);
    AppInfo appInfo3 = new AppInfo("Michael同学", 0);
    Observable.just(appInfo1, appInfo2, appInfo3);

    //源码
    public static  Observable just(T t1, T t2, T t3) {
        return from((T[])new Object[] { t1, t2, t3 });
    }
    单个对象转数组



第二个：repeat()方法


public final class OnSubscribeRedo implements OnSubscribe {
    final Observable source;
    private final Func1>, ? extends Observable> controlHandlerFunction;
    final boolean stopOnComplete;
    final boolean stopOnError;
    private final Scheduler scheduler;

    static final Func1>, Observable> REDO_INFINITE = new Func1>, Observable>() {
        @Override
        public Observable call(Observable> ts) {
            return ts.map(new Func1, Notification>() {
                @Override
                public Notification call(Notification terminal) {
                    return Notification.createOnNext(null);
                }
            });
        }
    };

    public static final class RedoFinite implements Func1>, Observable> {
        final long count;

        public RedoFinite(long count) {
            this.count = count;
        }

        @Override
        public Observable call(Observable> ts) {
            return ts.map(new Func1, Notification>() {

                int num;

                @Override
                public Notification call(Notification terminalNotification) {
                    if (count == 0) {
                        return terminalNotification;
                    }

                    num++;
                    if (num <= count) {
                        return Notification.createOnNext(num);
                    } else {
                        return terminalNotification;
                    }
                }

            }).dematerialize();
        }
    }

    public static final class RetryWithPredicate implements Func1>, Observable>> {
        final Func2 predicate;

        public RetryWithPredicate(Func2 predicate) {
            this.predicate = predicate;
        }

        @Override
        public Observable> call(Observable> ts) {
            return ts.scan(Notification.createOnNext(0), new Func2, Notification, Notification>() {
                @SuppressWarnings("unchecked")
                @Override
                public Notification call(Notification n, Notification term) {
                    final int value = n.getValue();
                    if (predicate.call(value, term.getThrowable())) {
                        return Notification.createOnNext(value + 1);
                    } else {
                        return (Notification) term;
                    }
                }
            });
        }
    }

    public static  Observable retry(Observable source) {
       return retry(source, REDO_INFINITE);
    }

    public static  Observable retry(Observable source, final long count) {
        if (count < 0) {
            throw new IllegalArgumentException("count >= 0 expected");
        }
        if (count == 0) {
            return source;
        }
        return retry(source, new RedoFinite(count));
    }

    public static  Observable retry(Observable source, Func1>, ? extends Observable> notificationHandler) {
        return unsafeCreate(new OnSubscribeRedo(source, notificationHandler, true, false, Schedulers.trampoline()));
    }

    public static  Observable retry(Observable source, Func1>, ? extends Observable> notificationHandler, Scheduler scheduler) {
        return unsafeCreate(new OnSubscribeRedo(source, notificationHandler, true, false, scheduler));
    }

    public static  Observable repeat(Observable source) {
        return repeat(source, Schedulers.trampoline());
    }

    public static  Observable repeat(Observable source, Scheduler scheduler) {
        return repeat(source, REDO_INFINITE, scheduler);
    }

    public static  Observable repeat(Observable source, final long count) {
        return repeat(source, count, Schedulers.trampoline());
    }

    public static  Observable repeat(Observable source, final long count, Scheduler scheduler) {
        if (count == 0) {
            return Observable.empty();
        }
        if (count < 0) {
            throw new IllegalArgumentException("count >= 0 expected");
        }
        return repeat(source, new RedoFinite(count - 1), scheduler);
    }

    public static  Observable repeat(Observable source, Func1>, ? extends Observable> notificationHandler) {
        return unsafeCreate(new OnSubscribeRedo(source, notificationHandler, false, true, Schedulers.trampoline()));
    }

    public static  Observable repeat(Observable source, Func1>, ? extends Observable> notificationHandler, Scheduler scheduler) {
        return unsafeCreate(new OnSubscribeRedo(source, notificationHandler, false, true, scheduler));
    }

    public static  Observable redo(Observable source, Func1>, ? extends Observable> notificationHandler, Scheduler scheduler) {
        return unsafeCreate(new OnSubscribeRedo(source, notificationHandler, false, false, scheduler));
    }

    private OnSubscribeRedo(Observable source, Func1>, ? extends Observable> f, boolean stopOnComplete, boolean stopOnError,
            Scheduler scheduler) {
        this.source = source;
        this.controlHandlerFunction = f;
        this.stopOnComplete = stopOnComplete;
        this.stopOnError = stopOnError;
        this.scheduler = scheduler;
    }

    @Override
    public void call(final Subscriber child) {

        // when true is a marker to say we are ready to resubscribe to source
        final AtomicBoolean resumeBoundary = new AtomicBoolean(true);

        // incremented when requests are made, decremented when requests are fulfilled
        final AtomicLong consumerCapacity = new AtomicLong();

        final Scheduler.Worker worker = scheduler.createWorker();
        child.add(worker);

        final SerialSubscription sourceSubscriptions = new SerialSubscription();
        child.add(sourceSubscriptions);

        // use a subject to receive terminals (onCompleted and onError signals) from
        // the source observable. We use a BehaviorSubject because subscribeToSource
        // may emit a terminal before the restarts observable (transformed terminals)
        // is subscribed
        final Subject, Notification> terminals = BehaviorSubject.>create().toSerialized();
        final Subscriber> dummySubscriber = Subscribers.empty();
        // subscribe immediately so the last emission will be replayed to the next
        // subscriber (which is the one we care about)
        terminals.subscribe(dummySubscriber);

        final ProducerArbiter arbiter = new ProducerArbiter();

        final Action0 subscribeToSource = new Action0() {
            @Override
            public void call() {
                if (child.isUnsubscribed()) {
                    return;
                }

                Subscriber terminalDelegatingSubscriber = new Subscriber() {
                    boolean done;

                    @Override
                    public void onCompleted() {
                        if (!done) {
                            done = true;
                            unsubscribe();
                            terminals.onNext(Notification.createOnCompleted());
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        if (!done) {
                            done = true;
                            unsubscribe();
                            terminals.onNext(Notification.createOnError(e));
                        }
                    }

                    @Override
                    public void onNext(T v) {
                        if (!done) {
                            child.onNext(v);
                            decrementConsumerCapacity();
                            arbiter.produced(1);
                        }
                    }

                    private void decrementConsumerCapacity() {
                        // use a CAS loop because we don't want to decrement the
                        // value if it is Long.MAX_VALUE
                        while (true) {
                            long cc = consumerCapacity.get();
                            if (cc != Long.MAX_VALUE) {
                                if (consumerCapacity.compareAndSet(cc, cc - 1)) {
                                    break;
                                }
                            } else {
                                break;
                            }
                        }
                    }

                    @Override
                    public void setProducer(Producer producer) {
                        arbiter.setProducer(producer);
                    }
                };
                // new subscription each time so if it unsubscribes itself it does not prevent retries
                // by unsubscribing the child subscription
                sourceSubscriptions.set(terminalDelegatingSubscriber);
                source.unsafeSubscribe(terminalDelegatingSubscriber);
            }
        };

        // the observable received by the control handler function will receive notifications of onCompleted in the case of 'repeat'
        // type operators or notifications of onError for 'retry' this is done by lifting in a custom operator to selectively divert
        // the retry/repeat relevant values to the control handler
        final Observable restarts = controlHandlerFunction.call(
                terminals.lift(new Operator, Notification>() {
                    @Override
                    public Subscriber> call(final Subscriber> filteredTerminals) {
                        return new Subscriber>(filteredTerminals) {
                            @Override
                            public void onCompleted() {
                                filteredTerminals.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                filteredTerminals.onError(e);
                            }

                            @Override
                            public void onNext(Notification t) {
                                if (t.isOnCompleted() && stopOnComplete) {
                                    filteredTerminals.onCompleted();
                                } else if (t.isOnError() && stopOnError) {
                                    filteredTerminals.onError(t.getThrowable());
                                } else {
                                    filteredTerminals.onNext(t);
                                }
                            }

                            @Override
                            public void setProducer(Producer producer) {
                                producer.request(Long.MAX_VALUE);
                            }
                        };
                    }
                }));

        // subscribe to the restarts observable to know when to schedule the next redo.
        worker.schedule(new Action0() {
            @Override
            public void call() {
                restarts.unsafeSubscribe(new Subscriber(child) {
                    @Override
                    public void onCompleted() {
                        child.onCompleted();
                    }

                    @Override
                    public void onError(Throwable e) {
                        child.onError(e);
                    }

                    @Override
                    public void onNext(Object t) {
                        if (!child.isUnsubscribed()) {
                            // perform a best endeavours check on consumerCapacity
                            // with the intent of only resubscribing immediately
                            // if there is outstanding capacity
                            if (consumerCapacity.get() > 0) {
                                worker.schedule(subscribeToSource);
                            } else {
                                // set this to true so that on next request
                                // subscribeToSource will be scheduled
                                resumeBoundary.compareAndSet(false, true);
                            }
                        }
                    }

                    @Override
                    public void setProducer(Producer producer) {
                        producer.request(Long.MAX_VALUE);
                    }
                });
            }
        });

        child.setProducer(new Producer() {

            @Override
            public void request(final long n) {
                if (n > 0) {
                    BackpressureUtils.getAndAddRequest(consumerCapacity, n);
                    arbiter.request(n);
                    if (resumeBoundary.compareAndSet(true, false)) {
                        worker.schedule(subscribeToSource);
                    }
                }
            }
        });

    }
}


数据重复操作


第三个：defer()方法
 只有当订阅者订阅才创建Observable，为每个订阅创建一个新的Observable。内部通过OnSubscribeDefer在订阅时调用Func0创建Observable。（懒加载）


    private Observable observable;
    private AppInfoAdapter appInfoAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple9);
        observable = getApps();
        initView();
        // registerObserver();
    }

    private void initView() {
        ListView listView = (ListView) findViewById(R.id.lv_app_name);
        appInfoAdapter = new AppInfoAdapter(this);
        listView.setAdapter(appInfoAdapter);
    }

    /**
     * 创建Observable
     * 
     * @return
     */
    private Observable getApps() {
        // 一旦观察者订阅，那么会立马回调Func0中的call方法,创建Observable(懒加载)
        return Observable.defer(new Func0>() {

            // @Override
            // public Observable call() {
            // return Observable.create(new Observable.OnSubscribe() {
            //
            // @Override
            // public void call(Subscriber t) {
            // t.onNext(new AppInfo("梦想同学", 0));
            // t.onCompleted();
            // }
            // });
            // }

            @Override
            public Observable call() {
                Log.i("main", "创建了Observable......");
                AppInfo appInfo1 = new AppInfo("Michael同学", 0);
                AppInfo appInfo2 = new AppInfo("Michael同学", 0);
                AppInfo appInfo3 = new AppInfo("Michael同学", 0);
                return Observable.just(appInfo1, appInfo2, appInfo3).repeat(3);
            }

        });
    }

    public void click(View v) {
        observable.subscribe(new Observer() {

            @Override
            public void onCompleted() {
                // 完成之后刷新UI
                appInfoAdapter.notifyDataSetChanged();
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(AppInfo t) {
                // 添加数据
                appInfoAdapter.addAppInfo(t);
            }
        });
    }
点击onClick 加载9条数据



第四个：ranger()方法


    private Observable observable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple9);
        observable = getApps();
    }

    /**
     * 创建Observable
     * 
     * @return
     */
    private Observable getApps() {
    
        // 从指定位置开始发送，你需向后发送多少个
        // 第一个参数：起始值
        // 第二个参数：数量
        // 注意：第一个参数根据数量进行累加，之后发送
        // range()函数用两个数字作为参数：第一个是起始点，第二个是我们想发射数字的个数。
        return Observable.range(5, 5);
    }

    public void click(View v) {
        observable.subscribe(new Observer() {

            @Override
            public void onCompleted() {
                // 完成之后刷新UI
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer t) {
                // 添加数据
                Log.i("main", "接收到的数据: " + t);
            }
        });
    }

结果输出：
08-04 05:49:20.818 13051-13051/com.haocai.architect.rxjava I/main: 接收到的数据: 5
08-04 05:49:20.819 13051-13051/com.haocai.architect.rxjava I/main: 接收到的数据: 6
08-04 05:49:20.819 13051-13051/com.haocai.architect.rxjava I/main: 接收到的数据: 7
08-04 05:49:20.819 13051-13051/com.haocai.architect.rxjava I/main: 接收到的数据: 8
08-04 05:49:20.819 13051-13051/com.haocai.architect.rxjava I/main: 接收到的数据: 9




第五个：interval()方法
 interval()：创建一个按固定时间间隔发射整数序列的Observable
 这个比较好理解，interval()也是用来创建Observable的，并且也可以延迟发送。但interval()是按周期执行的，所以可以这么认为：interval()是一个可以指定线程的TimerTask（威力加强版……）


第六个：timer()方法


    private Observable observable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple9);
        observable = getApps();
    }

    /**
     * 创建Observable
     * 
     * @return
     */
    private Observable getApps() {
        // timer方法解释
        // 第一个参数：发送消息之间的间隔时间
        // 第二个参数：时间单位（毫秒、秒、分钟、小时等等......）
        return Observable.timer(3, TimeUnit.SECONDS);
    }

    public void click(View v) {
        // 轮训通知观察者
        observable.subscribe(new Observer() {

            @Override
            public void onCompleted() {
                // 完成之后刷新UI
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Long t) {
                // 添加数据
                Log.i("main", "接收到的数据: " + t);
            }
        });
    }

输出结果
08-04 08:25:14.754 24259-24357/com.haocai.architect.rxjava I/main: 接收到的数据: 0



总结：
 使用Observable步骤：
 准备观察者、准备Observable,注册观察者（observable.subscribe(new Observer())）、取消订阅(subscribe.unsubscribe()) 以及中间一些逻辑处理
























你可能感兴趣的:(响应式编程RxJava（二）)






    

  • 情绪觉察日记第37天
露露_e800

    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    

    • 

  • 一百九十四章. 自相矛盾
巨木擎天

    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    

    • 

  • 10月|愿你的青春不负梦想-读书笔记-01
Tracy的小书斋

    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    

    • 

  • C语言宏函数
南林yan
C语言c语言

    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<

    • 

  • 谢谢你们，爱你们！
鹿游儿

    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    

    • 

  • 爬山后遗症
璃绛

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

    • 

  • 《策划经理回忆录之二》
路基雅虎

    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    

    • 

  • 《大清方方案》| 第二话
谁佐清欢

    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    

    • 

  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    

    • 

  • 本周第二次约练
2cfbdfe28a51

    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
    

    • 

  • 2022-07-08
保利学府里李楚怡1307022

    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
    

    • 

  • 直抒《紫罗兰永恒花园外传》
雷姆的黑色童话

    没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
    

    • 

  • 基于社交网络算法优化的二维最大熵图像分割
智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言

    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    

    • 

  • 如果做到轻松在股市赚钱？只要坚持这三个原则。
履霜之人

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

    • 

  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业

    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    

    • 

  • 特殊的拜年
飘雪的天堂

    文/雪儿大年初一，家家户户没有了轰响的鞭炮声，大街上没有了人流涌动的喧闹，几乎看不到人影，变得冷冷清清。天刚亮不大会儿，村里的大喇叭响了起来：由于当前正值疾病高发期，流感流行的高峰期。同时，新型冠状病毒感染的肺炎进入第二波流行的上升期。为了自己和他人的健康安全着想，请大家尽量不要串门拜年，不要在街里走动。可以通过手机微信，视频，电话，信息拜年……今年的春节真是特别。禁止燃放鞭炮，烟花爆竹，禁止出村
    

    • 

  • 398顺境，逆境
戴骁勇

    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
    

    • 

  • 想明白这个问题，你才能写下去
文自拾

    春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
    

    • 

  • 【JS】执行时长(100分) |思路参考+代码解析（C++）
l939035548
JS算法数据结构c++

    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
    

    • 

  • 人工智能时代，程序员如何保持核心竞争力？
jmoych
人工智能

    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    

    • 

  • 其二
十八尾喵

    你知道吗？图片发自App我今天知道了你有喜欢的人，不是我。心空空的，整个人都不是我的了。可，怎么办？还是要好好的活着，毕竟你喜欢的人，我不能杀，可是我可以杀其他喜欢你的人呀！也罢，此生无缘，来世再见。鱼干
    

    • 

  • libyuv之linux编译
jaronho
Linuxlinux运维服务器

    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    

    • 

  • webpack图片等资源的处理
dmengmeng

    需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
    

    • 

  • ARM中断处理过程
落汤老狗
嵌入式linux

    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
    

    • 

  • 如何成为段子手
欣雅阅读

    我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
    

    • 

  • Python爬虫解析工具之xpath使用详解
eqa11
python爬虫开发语言

    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    

    • 

  • 主题升华随机抽总结
木棉咕噜

    昨天晚上在火山灿教练那里抽了主题升华最后一关。一共抽了两个故事，现总结如下。第一个故事是《并不是你想象的那样》。主题一：有时候，面对别人一些貌似不合常情的行为，不要轻易的指责他，也许背后有我们所不知道的原因。在这一个主题里面，刚开始的时候，我没有加上貌似二字。所以就没有改动之后这么精准。主题二：有时候我们对他人善意的行为，可能会给我们带来一些意外的回报。主题三：面对同样一件事，因为不同的人看待问题
    

    • 

  • C++菜鸟教程 - 从入门到精通 第二节
DreamByte
c++

    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
    

    • 

  • 这个世界为何对女性这么苛刻
遇见知见

    图片发自App当今社会的女性，简直用金刚侠来形容都不为过。虽然早已过了男尊女卑的时代，但是这个世界并没有平等的对待女性。新时代的女性标准：上得了厅堂，下得了厨房，杀得了木马，翻得了围墙，开得起好车，买得起新房，斗得过二奶，打得过流氓，生得了孩子，养得了家庭。这个社会对女性有太多的不公平，既要求女性经济独立，又要求女性贤良淑德。所有的女性的在成长过程中没有任何一项是因为你是女性而给你开绿灯的。图片发
    

    • 

  • 日常演播练习0822
开阳春天

    日常演播练习0822一、绕口令练习司小四和史小世，四月十四日十四时四十上集市，司小四买了四十四斤四两西红柿，史小世买了十四斤四两细蚕丝。司小四要拿四十四斤四两西红柿换史小世十四斤四两细蚕丝。史小世十四斤四两细蚕丝不换司小四四十四斤四两西红柿。司小四说我四十四斤四两西红柿可以增加营养防近视，史小世说我十四斤四两细蚕丝可以织绸织缎又抽丝。二、文本练习狗熊是动物街有名的美食家，它吃得多所以长得胖，它能吃
    

    • 

  • LeetCode[Math] - #66 Plus One
Cwind
javaLeetCode题解AlgorithmMath

    原题链接：#66 Plus One
 
要求：
给定一个用数字数组表示的非负整数，如num1 = {1, 2, 3, 9}, num2 = {9, 9}等，给这个数加上1。
注意：
1. 数字的较高位存在数组的头上，即num1表示数字1239
2. 每一位（数组中的每个元素）的取值范围为0~9
 
难度：简单
 
分析：
题目比较简单，只须从数组
    

    • 

  • JQuery中$.ajax()方法参数详解
AILIKES
JavaScriptjsonpjqueryAjaxjson

    url: 要求为String类型的参数，（默认为当前页地址）发送请求的地址。
type: 要求为String类型的参数，请求方式（post或get）默认为get。注意其他http请求方法，例如put和    delete也可以使用，但仅部分浏览器支持。
timeout: 要求为Number类型的参数，设置请求超时时间（毫秒）。此设置将覆盖$.ajaxSetup()方法的全局
    

    • 

  • JConsole & JVisualVM远程监视Webphere服务器JVM
Kai_Ge
JVisualVMJConsoleWebphere

        JConsole是JDK里自带的一个工具，可以监测Java程序运行时所有对象的申请、释放等动作，将内存管理的所有信息进行统计、分析、可视化。我们可以根据这些信息判断程序是否有内存泄漏问题。
　　使用JConsole工具来分析WAS的JVM问题，需要进行相关的配置。
　　首先我们看WAS服务器端的配置.
　　1、登录was控制台https://10.4.119.18
    

    • 

  • 自定义annotation
120153216
annotation

    Java annotation 自定义注释@interface的用法 一、什么是注释 
    说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。而J2SE5.0中提供的注释就是java源代码的元数据，也就是说注释是描述java源
    

    • 

  • CentOS 5/6.X 使用 EPEL YUM源
2002wmj
centos

    CentOS 6.X 安装使用EPEL YUM源1. 查看操作系统版本[root@node1 ~]# uname -a Linux node1.test.com 2.6.32-358.el6.x86_64 #1 SMP Fri Feb 22 00:31:26 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux [root@node1 ~]#
    

    • 

  • 在SQLSERVER中查找缺失和无用的索引SQL
357029540
SQL Server

    --缺失的索引
SELECT  avg_total_user_cost * avg_user_impact * ( user_scans + user_seeks ) AS PossibleImprovement , 
        last_user_seek , 
  
    

    • 

  • Spring3 MVC 笔记（二） —json+rest优化
7454103
Spring3 MVC

    接上次的 spring mvc 注解的一些详细信息！
                         其实也是一些个人的学习笔记  呵呵！

    

    • 

  • 替换“\”的时候报错Unexpected internal error near index 1 \ ^
adminjun
java“\替换”

    发现还是有些东西没有刻子脑子里,,过段时间就没什么概念了,所以贴出来...以免再忘...
 
在拆分字符串时遇到通过 \ 来拆分，可是用所以想通过转义 \\ 来拆分的时候会报异常
 
public class Main {  
  
    /*
    

    • 

  • POJ 1035 Spell checker(哈希表)
aijuans
暴力求解--哈希表

    /*
题意：输入字典，然后输入单词，判断字典中是否出现过该单词，或者是否进行删除、添加、替换操作，如果是，则输出对应的字典中的单词
要求按照输入时候的排名输出
题解：建立两个哈希表。一个存储字典和输入字典中单词的排名，一个进行最后输出的判重
*/
#include <iostream>
//#define
using namespace std;
const int HASH =
    

    • 

  • 通过原型实现javascript Array的去重、最大值和最小值
ayaoxinchao
JavaScriptarrayprototype

    用原型函数（prototype）可以定义一些很方便的自定义函数，实现各种自定义功能。本次主要是实现了Array的去重、获取最大值和最小值。
实现代码如下：
 
<script type="text/javascript">
Array.prototype.unique = function() {
var a = {};
var le
    

    • 

  • UIWebView实现https双向认证请求
bewithme
UIWebViewhttpsObjective-C

     
        什么是HTTPS双向认证我已在先前的博文 ASIHTTPRequest实现https双向认证请求
中有讲述，不理解的读者可以先复习一下。本文是用UIWebView来实现对需要客户端证书验证的服务请求，网上有些文章中有涉及到此内容，但都只言片语，没有讲完全，更没有完整的代码，让人困扰不已。但是此知
    

    • 

  • NoSQL数据库之Redis数据库管理(Redis高级应用之事务处理、持久化操作、pub_sub、虚拟内存)
bijian1013
redis数据库NoSQL

    3.事务处理
        Redis对事务的支持目前不比较简单。Redis只能保证一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。当一个client在一个连接中发出multi命令时，这个连接会进入一个事务上下文，该连接后续的命令不会立即执行，而是先放到一个队列中，当执行exec命令时，redis会顺序的执行队列中
    

    • 

  • 各数据库分页sql备忘
bingyingao
oraclesql分页

    ORACLE
下面这个效率很低
SELECT * FROM ( SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_FS_RETURN order by id desc) A ) WHERE RN <20;
下面这个效率很高
SELECT A.*, ROWNUM RN FROM (SELECT * FROM IPAY_RCD_
    

    • 

  • 【Scala七】Scala核心一：函数
bit1129
scala

    1. 如果函数体只有一行代码，则可以不用写{},比如
def print(x: Int) = println(x)
一行上的多条语句用分号隔开，则只有第一句属于方法体，例如
 
def printWithValue(x: Int) : String= println(x); "ABC"
 
上面的代码报错，因为，printWithValue的方法
    

    • 

  • 了解GHC的factorial编译过程
bookjovi
haskell

    GHC相对其他主流语言的编译器或解释器还是比较复杂的，一部分原因是haskell本身的设计就不易于实现compiler，如lazy特性，static typed，类型推导等。
关于GHC的内部实现有篇文章说的挺好，这里，文中在RTS一节中详细说了haskell的concurrent实现，里面提到了green thread，如果熟悉Go语言的话就会发现，ghc的concurrent实现和Go有点类
    

    • 

  • Java-Collections Framework学习与总结-LinkedHashMap
BrokenDreams
LinkedHashMap

            前面总结了java.util.HashMap，了解了其内部由散列表实现，每个桶内是一个单向链表。那有没有双向链表的实现呢？双向链表的实现会具备什么特性呢？来看一下HashMap的一个子类——java.util.LinkedHashMap。
      
    

    • 

  • 读《研磨设计模式》-代码笔记-抽象工厂模式-Abstract Factory
bylijinnan
abstract

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
package design.pattern;
/*
* Abstract Factory Pattern
* 抽象工厂模式的目的是：
* 通过在抽象工厂里面定义一组产品接口，方便地切换“产品簇”
* 这些接口是相关或者相依赖的
    

    • 

  • 压暗面部高光
cherishLC
PS

    方法一、压暗高光&重新着色
当皮肤很油又使用闪光灯时，很容易在面部形成高光区域。
下面讲一下我今天处理高光区域的心得：
皮肤可以分为纹理和色彩两个属性。其中纹理主要由亮度通道（Lab模式的L通道）决定，色彩则由a、b通道确定。
处理思路为在保持高光区域纹理的情况下，对高光区域着色。具体步骤为：降低高光区域的整体的亮度，再进行着色。
如果想简化步骤，可以只进行着色（参看下面的步骤1
    

    • 

  • Java VisualVM监控远程JVM
crabdave
visualvm

    Java VisualVM监控远程JVM 
 
JDK1.6开始自带的VisualVM就是不错的监控工具.
这个工具就在JAVA_HOME\bin\目录下的jvisualvm.exe, 双击这个文件就能看到界面
 
通过JMX连接远程机器, 需要经过下面的配置:
1. 修改远程机器JDK配置文件 (我这里远程机器是linux).
   
    

    • 

  • Saiku去掉登录模块
daizj
saiku登录olapBI

    
1、修改applicationContext-saiku-webapp.xml
<security:intercept-url pattern="/rest/**" access="IS_AUTHENTICATED_ANONYMOUSLY" /> 
<security:intercept-url pattern=&qu
    

    • 

  • 浅析 Flex中的Focus
dsjt
htmlFlexFlash

    关键字：focus、 setFocus、 IFocusManager、KeyboardEvent
焦点、设置焦点、获得焦点、键盘事件
一、无焦点的困扰——组件监听不到键盘事件
原因：只有获得焦点的组件（确切说是InteractiveObject）才能监听到键盘事件的目标阶段；键盘事件（flash.events.KeyboardEvent）参与冒泡阶段，所以焦点组件的父项（以及它爸
    

    • 

  • Yii全局函数使用
dcj3sjt126com
yii

    由于YII致力于完美的整合第三方库，它并没有定义任何全局函数。yii中的每一个应用都需要全类别和对象范围。例如，Yii::app()->user;Yii::app()->params['name'];等等。我们可以自行设定全局函数，使得代码看起来更加简洁易用。(原文地址)
我们可以保存在globals.php在protected目录下。然后，在入口脚本index.php的，我们包括在
    

    • 

  • 设计模式之单例模式二（解决无序写入的问题）
come_for_dream
单例模式volatile乱序执行双重检验锁

                    在上篇文章中我们使用了双重检验锁的方式避免懒汉式单例模式下由于多线程造成的实例被多次创建的问题，但是因为由于JVM为了使得处理器内部的运算单元能充分利用，处理器可能会对输入代码进行乱序执行（Out Of Order Execute）优化，处理器会在计算之后将乱序执行的结果进行重组，保证该
    

    • 

  • 程序员从初级到高级的蜕变
gcq511120594
框架工作PHPandroidhtml5

    软件开发是一个奇怪的行业，市场远远供不应求。这是一个已经存在多年的问题，而且随着时间的流逝，愈演愈烈。
我们严重缺乏能够满足需求的人才。这个行业相当年轻。大多数软件项目是失败的。几乎所有的项目都会超出预算。我们解决问题的最佳指导方针可以归结为——“用一些通用方法去解决问题，当然这些方法常常不管用，于是，唯一能做的就是不断地尝试，逐个看看是否奏效”。
现在我们把淫浸代码时间超过3年的开发人员称为
    

    • 

  • Reverse Linked List
hcx2013
list

    Reverse a singly linked list.
 
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
p
    

    • 

  • Spring4.1新特性——数据库集成测试
jinnianshilongnian
spring 4.1

    目录
Spring4.1新特性——综述
Spring4.1新特性——Spring核心部分及其他
Spring4.1新特性——Spring缓存框架增强
Spring4.1新特性——异步调用和事件机制的异常处理
Spring4.1新特性——数据库集成测试脚本初始化
Spring4.1新特性——Spring MVC增强
Spring4.1新特性——页面自动化测试框架Spring MVC T
    

    • 

  • C# Ajax上传图片同时生成微缩图(附Demo)
liyonghui160com

     
 
1.Ajax无刷新上传图片,详情请阅我的这篇文章。（jquery + c# ashx）
        2.C#位图处理  System.Drawing。
        3.最新demo支持IE7,IE8,Fir
    

    • 

  • Java list三种遍历方法性能比较
pda158
java

    从c/c++语言转向java开发，学习java语言list遍历的三种方法，顺便测试各种遍历方法的性能，测试方法为在ArrayList中插入1千万条记录，然后遍历ArrayList，发现了一个奇怪的现象，测试代码例如以下：
package com.hisense.tiger.list;
import java.util.ArrayList;
import java.util.Iterator;
    

    • 

  • 300个涵盖IT各方面的免费资源（上）——商业与市场篇
shoothao
seo商业与市场IT资源免费资源

    
A.网站模板+logo+服务器主机+发票生成
HTML5 UP:响应式的HTML5和CSS3网站模板。
Bootswatch:免费的Bootstrap主题。
Templated:收集了845个免费的CSS和HTML5网站模板。
Wordpress.org|Wordpress.com:可免费创建你的新网站。
Strikingly:关注领域中免费无限的移动优
    

    • 

  • localStorage、sessionStorage
uule
localStorage

    W3School 例子
 
HTML5 提供了两种在客户端存储数据的新方法：
localStorage - 没有时间限制的数据存储
sessionStorage - 针对一个 session 的数据存储
 
之前，这些都是由 cookie 完成的。但是 cookie 不适合大量数据的存储，因为它们由每个对服务器的请求来传递，这使得 cookie 速度很慢而且效率也不
    

    •