AntCoding
AntCoding

RxJava详解-线程切换原理篇

概要

RxJava最神秘的部分莫过于此,我为了编写这篇文章也是一遍一遍的查看源码寻找它的运行原理，同样的也查阅了很多的相关资料，但是惭愧的是并未找到实质性有用的资料，很多都是避开这话题避而不谈，在此我们详细的对它进行剖析。
不得不说这个框架编写的真的很棒，相关类也是错综复杂，不过作为程序员我们必须拿出积极的态度来学习它的实现，以此提高自身的价值；好了废话不多说我们马上开始。

源码剖析

我们先来看一下外部的实现调用

public void onMineTask() {
        //声明一个ObservableCreate类型的 被观察者对象
        Observable mObservable = new ObservableCreate(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext("ONE");
                e.onNext("TWO");
                e.onNext("THREE");
                e.onNext("FOUR");
            }
        });
        //声明一个Observer类型的观察者对象
        Observer observer = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                disposable = d;
                Log.e("回调执行了onSubscribe函数->", "观察者已成功订阅");
            }

            @Override
            public void onNext(String value) {
                if (disposable.isDisposed())
                    onComplete();

                value = mine_result.getText().toString() + "\n" + value;
                mine_result.setText(value);
                Log.e("回调执行了onNext函数->", value);

            }

            @Override
            public void onError(Throwable e) {
                Log.e("回调执行了onError函数->", e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.e("回调执行了onComplete函数->", "本次结束!");
            }
        };
       //指定被观察者和观察者运行的线程
       //指定 被观察者线程      ObservableSubscribeOn类型
        mObservable.subscribeOn(Schedulers.io())  
                 //指定 观察者线程    ObservableObserveOn类型
                .observeOn(AndroidSchedulers.mainThread()) 
                 //事件发布
                .subscribe(observer);
    }

我们通过上述的代码可以看出mObservable它是ObservableCreate类型，通过他调取了[1]subscribeOn(Schedulers.io())来指定被观察者的执行线程，并返回一个Observable类型的返回值，当然这个Observable类型是个抽象类型；
而获取到Observable类型的返回值之后，我们有调用了[2]observeOn(AndroidSchedulers.mainThread())函数方法，实现了对观察者执行线程的指定，此时我们得到返回值依旧是Observable类型；
最终我们依旧使用Observable类型的返回值，通过调取[3]subscribe(observer)函数实现主题发布，并携带着observer观察者实例。
那么我们接下来，就按序讲解他们的执行的过程：

[ 1 ] subscribeOn(Schedulers.io())函数方法，源码解析

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable subscribeOn(Scheduler scheduler) {
        //此处查Null操作
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        //这里是一个钩子函数，在无扩展性特殊操作情况下，
        //原封不动的返回一个ObservableSubscribeOn类型的值，
        //而由于它的基类是 Observable类型，所以我们直接将其基类类型
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
    }

我们来看RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler))函数方法，它其实是一个钩子函数，在无扩展性特殊操作情况下，会原封不动的返回一个ObservableSubscribeOn类型的值，而由于它的基类是 Observable类型，所以我们直接将其基类类型返回。

而我们重点来看这方法中的参数new ObservableSubscribeOn(this, scheduler)，它是声明了一个ObservableSubscribeOn类型对象，并传入了一个Observable类型的被观察者，但由于Observable实现了ObservableSource的接口，而我们也只需要ObservableSource这部分内容,所以最终声明ObservableSubscribeOn类型实例，我们传入的是一个ObservableSource类型参数和一个指定运行线程的Scheduler类型参数.

在ObservableSubscribeOn类中我们对subscribeActual(final Observer observer)抽象方法进行了实现.但目前还未进行调用

[ 2 ]observeOn(AndroidSchedulers.mainThread())函数方法，源码解析

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable observeOn(Scheduler scheduler) {
        //调用其自身的多态方法
        return observeOn(scheduler, false, bufferSize());
    }

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        //省略...
        //钩子函数，若无扩展性特殊逻辑实现依旧返回一个`ObservableObserveOn`类型的值，
        //由于`Observable`是其基类，所以这里直接将其基类类型返回值
        return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize));
    }

此方法与[ 1 ]中的方法一样这里不再赘述，我们的重点是其参数new ObservableObserveOn(this, scheduler, delayError, bufferSize)，它返回是一个ObservableObserveOn类型的值，但由于它的基类是Observable类型，所以此处直接按基类类型返回，它携带参数包括
ObservableSource类型的this；Scheduler类型的执行线程；boolean类型的延迟错误，指示onError通知是否不能在另一侧的onNext通知之前切换；int类型的缓冲区大小.

ObservableObserveOn类同样对`subscribeActual(final Observer observer)抽象方法进行了实现.但目前还未进行调用.

[ 3 ]subscribe(observer)函数实现主题发布,携带着观察者参数。源码解析:

 @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer observer) {
       //省略...
            //调取 subscribeActual抽象方法
            subscribeActual(observer);
        } 
      //省略...
    }

我们来看subscribeActual(observer)这个函数，我们的被观察者的ObservableSubscribeOn和观察者的ObservableObserveOn分别都重写了此函数，那么此处的subscribeActual(observer)将进入哪个类呢？
我们将外部的调用链式表达分解一下来看:

     Observable observableSubscribeOn1 = mObservable.subscribeOn(Schedulers.io()); //第一次
        //指定 观察者线程    ObservableObserveOn类型
        Observable observeObserveOn2 = observableSubscribeOn1.observeOn(AndroidSchedulers.mainThread());
        //发布执行
        observeObserveOn2.subscribe(observer);

很清晰的我们能看到,最终对subscribe(observer)函数方法发起调用的是观察者的ObservableObserveOn类，所以我们将会执行ObservableObserveOn类中的subscribeActual(observer)实现

 public ObservableObserveOn(ObservableSource source, Scheduler 
    @Override
    protected void subscribeActual(Observer observer) {
     //省略...
            //创建一个线程，当前创建出来的是一个Handler线程
            Scheduler.Worker w = scheduler.createWorker();
            //此处我们调用上一个Observable类型对象的发布事件
            //即 被观察者对象的发布事件
            source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
        }
    }

首先明确一点此处的source对象是被观察者的Observable类型实例，由于在指定运行线程时我们都传入一个Observable类型对象，而传递的Observable都是上一个对象的实例。
此处的参数new ObserveOnObserver(observer, w, delayError, bufferSize)是声明的ObservableObserveOn类的静态内部类的实例。

    static final class ObserveOnObserver extends BasicIntQueueDisposable
    implements Observer, Runnable {
    ObserveOnObserver(Observer actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
            this.downstream = actual;
            this.worker = worker;
            this.delayError = delayError;
            this.bufferSize = bufferSize;
        }
}

可以看出它实现了Observer接口，而我们在source.subscribe(...)方法中也仅需要这部分内容，至此我们又回到了Observable类中的subscribe(Observer observer)函数方法。

public final void subscribe(Observer observer) {
       //省略...
            subscribeActual(observer);
       //省略...

而再次调用subscribeActual(observer)函数方法，不会再进入到ObservableObserveOn类中，而是进入ObservableSubscribeOn类，执行其subscribeActual(final Observer observer)实现方法

@Override
    public void subscribeActual(final Observer observer) {
  //将观察者包装成ObservableObserveOn类型
  final SubscribeOnObserver parent = new SubscribeOnObserver(observer);
        //[ 3.1 ]调用此方法会进入观察者`ObservableObserveOn`类中的实现方法
        //可以看出此处还没进行被观察者的线程指定
        observer.onSubscribe(parent);
        //[ 3.2 ]在此处设置被观察者的运行线程
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

[ 3.1 ] 我们来看看observer.onSubscribe(parent)，它在ObservableObserveOn类的内部类ObserveOnObserver的onSubscribe(Disposable d)做了什么

 @Override
        public void onSubscribe(Disposable d) {
               //省略...
                downstream.onSubscribe(this);
            }
        }

downstream对象使我们在创建ObserveOnObserver类型实例时传入的Observer类型实例，即观察者实例，而它调取onSubscribe(this)方法后直接回调至我们的外部实现中所创建的观察者对象的onSubscribe(Disposable d)中，通知观察者订阅成功。

[ 3.2 ] 接下来分析一下parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)))方法是如何指定被观察者运行线程的,

先来分析他参数实现scheduler.scheduleDirect(new SubscribeTask(parent)),

[ 3.2.1 ] 来看new SubscribeTask(parent)做了什么

//实现Runnable 接口
final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver parent;

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

        @Override
        public void run() {
             //调取事件发布事件,而此处的source是`ObservableCreate`类型
            source.subscribe(parent);
        }
    }

此处实现了Runnable接口，并在重写的run()方法中调取了source.subscribe(parent)，首先明确此时的source对象它的类型是谁?答案是ObservableCreate，因为在创建ObservableSubscribeOn类型实例时传入的ObservableSource类型参数是上一个对象，所以在执行subscribe(parent)方法后我们会通过subscribeActual(observer)方法函数，进入到ObservableCreate类中对subscribeActual(observer)方法实现；而在此处我们还未进行有效的调用.

[ 3.2.2 ] 分析完SubscribeTask后我们接着分析他外层scheduler.scheduleDirect(new SubscribeTask(parent))方法做了什么

   @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run) {
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }
  @NonNull
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        //创建一个Worker线程,
        final Worker w = createWorker();
         //钩子函数,若无扩展性特殊处理则返回参数本身
        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
        //声明一个处理任务，将Runnable和Work封装成DisposeTask
        DisposeTask task = new DisposeTask(decoratedRun, w);
        //调取woker对象的schedule方法
        w.schedule(task, delay, unit);
        return task;
    }

<3.2.2.1> 我们先调用了createWorker()函数创建了一个EventLoopWorker类型对象，利用它实现线程调度；而EventLoopWorker继承于Scheduler.Worker抽象类

static final class EventLoopWorker extends Scheduler.Worker {
       //省略... 
         //结束操作
        @Override
        public void dispose() {
            if (once.compareAndSet(false, true)) {
                tasks.dispose();
                // 释放线程池操作
                pool.release(threadWorker);
            }
        }
        //是否结束
        @Override
        public boolean isDisposed() {
            return once.get();
        }
       //重写进程调度
        @NonNull
        @Override
        public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
            if (tasks.isDisposed()) {
                // don't schedule, we are unsubscribed
                return EmptyDisposable.INSTANCE;
            }
            //执行线程调度执行
            return threadWorker.scheduleActual(action, delayTime, unit, tasks);
        }
    }

<3.2.2.2> 然后声明了一个DisposeTask类型对象，将Runnable对象和线程调度器包装在一起，而DisposeTask类实现了Runnable接口，重写了run()函数方法，

static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {
      //省略...
        @Override
        public void run() {
            runner = Thread.currentThread();
            try {
                 //执行Runnable
                decoratedRun.run();
            } finally {
                dispose();
                runner = null;
            }
        }

        //省略...
    }

<3.2.2.3> 完成上述预备工作后，我们开始调用w.schedule(task, delay, unit)方法进行任务执行

     @NonNull
        @Override
        public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
           //判定任务是否成功被订阅
            if (tasks.isDisposed()) {
                // 若没有被订阅,则不作任何处理
                return EmptyDisposable.INSTANCE;
            }
            //进行线程调度
            return threadWorker.scheduleActual(action, delayTime, unit, tasks);
        }
    }

<3.2.2.4> 调用 scheduleActual()进行线程任务调度

public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
        ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
 //      省略...
        try {
//      线程提交
            if (delayTime <= 0) {
                f = executor.submit((Callable)sr);
            } else {
                f = executor.schedule((Callable)sr, delayTime, unit);
            }
            sr.setFuture(f);
        } catch (RejectedExecutionException ex) {
            if (parent != null) {
                parent.remove(sr);
            }
            RxJavaPlugins.onError(ex);
        }

        return sr;
    }
 
 
线程被提交后，会交给Executor来执行，调用Runnable接口的run方法，那么这就简单了.
 
 
小结
 
 
 
  
在上述操作中我们成功的将[被观察者]提交给了指定的线程去执行，那么接下来就是线程向上执行调取被观察者的run()的流程了，别头大，这个框架的复杂度就是那么绕~~~，想要成长我们就得迈过这道坎,毕竟成长的就是这么痛苦！！
 这里我建议一下，阅读这样复杂的框架的时候我们最好在Debug模式下,跟随着框架流程进行学习····好了休息一下吧！我们马上开始下半场的学习。
 
 
 
 
 
  
[ 3.3 ]我们在<3.2.2.4>()中执行的scheduleActual()中将Runnable封装成了ScheduledRunnable类型,那么首先执行进入它的里面，看看它的run()方法做了什么诡谲的操作.
 
 
 
 
public void run() {
        lazySet(THREAD_INDEX, Thread.currentThread());
        try {
            try {
                //获取的上层的Runnable对象,执行其run方法
                actual.run();
            } catch (Throwable e) {
               //若发生异常,则直接调用onError通知观察者
                RxJavaPlugins.onError(e);
            }
        //省略....
    }

 
 
可以看到ScheduledRunnable类中的run()并未做什么特殊操作,而是执行了上层的Runnable类型对象的run()方法，那么它的上层是谁呢？
 
 
 
  
[ 3.4 ] 目光转向[ 3.2.2 ]的源码，我们将其中把Runnable和Work类型对象关联了起来，并封装成了一个DisposeTask类型对象，那么废话不多说我们直接去看看其中的源码
 
 
 
 
  @Override
        public void run() {
            runner = Thread.currentThread();
            try {
                decoratedRun.run();
            } finally {
                dispose();
                runner = null;
            }
        }

 
 
[ 3.5 ]依旧是继续向上调取，我最终回到了ObservableSubscribeOn类中内部类SubscribeOnObserver中的内部类的SubscribeTask的run()方法，饶了这么大一圈最终还是回到了最初始调取的地方才有实质的处理操作_!! 来看看吧
 
 
 final class SubscribeTask implements Runnable {
//      省略...
        @Override
        public void run() {
            //调取被观察者的 subscribe方法
            source.subscribe(parent);
        }
    }

 
 
 
  
[ 3.6 ] 此时的source就是外部第一次声明的Observable类型对象的实例了，即ObservableCreate类，那么我们将再次回到Observable类中执行其subscribe(Observer observer)函数，老套路来看吧！
 
 
 
 
 public final void subscribe(Observer observer) {
        //省略...
            subscribeActual(observer);
      //省略...
    }

 
 
 
  
[ 3.7 ]我们又一次要执行subscribeActual(observer)方法了，那么这次我们要进入哪个类呢？猜对了就是ObservableCreate类
 
 
 
 
 @Override
    protected void subscribeActual(Observer observer) {
        //将观察者封装成CreateEmitter类型
        CreateEmitter parent = new CreateEmitter(observer);
         //回调观察者的接口，告诉观察者订阅成功,
         //并将新封装的观察者传递过去
        observer.onSubscribe(parent);
        try {
            //回调外部被观察者的接口，告诉被观察者主题已被订阅,
           //可进行接下来相关操作了,并将最新封装的观察者对象传入
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

 
 
 
  
[ 3.8 ] 终于出去了=_=!! 我们首先通知观察者成功订阅主题，然后再告诉被观察者被成功订阅,可以新进行接下来的主题发布了!!
 
 
 
 
 Observable mObservable = new ObservableCreate(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                //[ 4 ]发布下一个
                e.onNext("ONE");
                e.onNext("TWO");
                e.onNext("THREE");
                e.onNext("FOUR");
            }
        });
        Observer observer = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e("回调执行了onSubscribe函数->", "观察者已成功订阅");
            }
            @Override
            public void onNext(String value) {
                Log.e("回调执行了onNext函数->", value);
            }
            @Override
            public void onError(Throwable e) {
                Log.e("回调执行了onError函数->", e.getMessage());
            }
            @Override
            public void onComplete() {
                Log.e("回调执行了onComplete函数->", "本次结束!");
            }
        };

 
 
 
  
[ 3.8.1 ]调取ObservableEmitter类型的观察者的onNext(Object value)方法
 
 
 
 
 @Override
        public void onNext(T t) {
          //省略...
            if (!isDisposed()) {
                //调取未进行包装的观察者的onNext方法函数
                observer.onNext(t);
            }
        }

 
 
 
  
[ 3.8.2 ]这里的并没有进行任何处理，而是调取了上层的SubscribeOnObserver类型的观察者的onNext(Object value)
 
 
 
 
   @Override
        public void onNext(T t) {
            downstream.onNext(t);
        }

 
 
 
  
[ 3.8.3 ] 这里依旧是继续向上调取，通过调取上层的ObserveOnObserver类型的观察者的onNext(Object value)方法
 
 
 
 
 @Override
        public void onNext(T t) {
           //省略
            schedule();
        }
  void schedule() {
            if (getAndIncrement() == 0) {
                //进行线程调度，并将观察者传入
                worker.schedule(this);
            }
        }


 
 
 
  
[ 3.8.4 ]此处进行观察者执行线程的调度,由于我们在外部指定观察者运行于UI线程，所以此处我们HandlerScheduler类的schedule(Runnable run, long delay, TimeUnit unit)方法中
 
 
 
 
public abstract class Scheduler {
   public abstract static class Worker implements Disposable {     
        @NonNull
        public Disposable schedule(@NonNull Runnable run) {
            return schedule(run, 0L, TimeUnit.NANOSECONDS);
        }
   }
}

 
 
final class HandlerScheduler extends Scheduler {
   private static final class HandlerWorker extends Worker {
      public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
            //省略...
             //将handle和run关联起来包装成新对象
            ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
            Message message = Message.obtain(handler, scheduled);
            message.obj = this;
            if (async) {
                message.setAsynchronous(true);
            }
           //handler发送消息
            handler.sendMessageDelayed(message, unit.toMillis(delay));
            //省略...
            return scheduled;
        }
    }
}

 
 
 
  
[ 3.8.5 ] 我们在这里将Runnable包装成Message同过Handler进行发送，这将进入到Hanlder类中的runWithScissors(final Runnable r, long timeout)方法
 
 
 
 
public final boolean runWithScissors(final Runnable r, long timeout) {
        //省略
        if (Looper.myLooper() == mLooper) {
            //执行Runnable接口的run()方法
            r.run();
            return true;
        }
        //省略...
    }

 
 
 
  
[ 3.8.6 ] 通过判定我们当前运行的线程是否跟Handler所在的线程是否一致 ，如果一致直接运行Runnable的run()方法，即我们再次回到了HandlerScheduler类中的内部类HandlerWorker下，执行其run()方法
 
 
 
 
 @Override
        public void run() {
            try {
                delegate.run();
            } catch (Throwable t) {
                RxJavaPlugins.onError(t);
            }
        }

 
 
 
  
[ 3.8.7 ]没有意外，这没有进行任何处理，继续向上传递进入ObservableObserveOn类的run()中
 
 
 
 
 @Override
        public void run() {
         //省略...
         drainNormal();
        }
void drainNormal() {
           //省略...
                    a.onNext(v);
          //省略...
        }

 
 
 
  
[ 3.8.8 ] 可以看到在此处我们回调了外部声明观察者接口的onNext(Object value)方法，进而执行我们自定义的业务！！！
 
 
 
 
    @Override
            public void onNext(String value) {
                if (disposable.isDisposed())
                    onComplete();
                value = mine_result.getText().toString() + "\n" + value;
                mine_result.setText(value);
                Log.e("回调执行了onNext函数->", value);
            }

 
 
小结
 
 
 
  
至此完成了线程切换的全部过程，不得不说这个框架的复杂程度尤其之高，为了写这篇文章也是累的自己一头的汗=_=!! 一开始分析源码的时候真是一个头两个大，主要是其中的类粘连性太强了，特别容易把自己搞得晕头转向，不过分析完之后脑中也就豁然开朗了。
 由于篇幅太长，我们将整体流程大致的再进行一下梳理，之后我会将流程图奉上！！
 
 
 
 
流程梳理
 
 
 
  
     
   
  •  
    
       
     
    1. 我们在外部声明一个ObservableCreate类型被观察者 0实例和Observer类型的观察者实例
      2.  
    
    •  
   
  •  
    
       
     
    1. 调取[被观察者]的subscribeOn(Schedulers.io())方法指定被观察者的执行线程，方法执行期间会声明一个ObservableSubscribeOn类型对象作为参数传入,它的父类继承于Observable抽象类，随后获取一个新的被观察者1；
      2.  
    
    •  
   
  •  
    
       
     
    1. 然后再调取observeOn(AndroidSchedulers.mainThread())方法来指定观察者的执行线程，方法执行期间会声明一个ObservableObserveOn类型对象作为参数传入,它的父类同样继承于Observable抽象类，再次返回一个新的被观察者2 
      2.  
    
    •  
   
  • 4.使用最新的[被观察者]调取subscribe(observer)方法进行主题发布，并将观察者作为参数传入。
    •  
   
  • 5.调用新的被观察者2 对象的subscribeActual(Observer observer)方法，创建一个执行线程,调取新的被观察者1的subscribe(Observer observer)方法，比创建一个ObserveOnObserver类型对象传入
    •  
   
  • 6.调用新的被观察者1 对象的subscribeActual(Observer observer)方法，创建一个执行线程，在线程的run()方法中调取被观察者 0的subscribe(Observer observer)方法，声明一个SubscribeOnObserver类型的对象传入
    •  
   
  • 7.调用被观察者0 对象的subscribeActual(Observer observer)方法，通过调取被观察者的subscribe(ObservableEmitter e)方法，回调到了我们的外部实现.
    •  
   
  • 8.在外部的subscribe(...)方法，调取观察者的onNext(Object value)方法，而此时的观察者经过一套流程下来也是被进行的层层包装，最终回调到了我们的外部实现.
    •  
  
 
 
 
 
这篇文章篇幅我有点长，希望有兴趣的同学慢慢读，之后我把流程图梳理完毕后会如数奉上~~~
 
 
此文章只代表个人理解观点，如有差错希望积极之处，我们共同交流!!!
 
 
This ALL! Thanks EveryBody!
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(RxJava详解-线程切换原理篇)

        

            

                
    
                    
  • Python中os.environ基本介绍及使用方法
                        鹤冲天Pro
#Pythonpython服务器开发语言
                        
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
    
                    
    • 
                    
  • SQL Server_查询某一数据库中的所有表的内容
                        qq_42772833
SQLServer数据库sqlserver
                        
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
                        nseejrukjhad
langchaineasyui前端python
                        
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • 01-Git初识
                        Meereen
Gitgit
                        
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    
                    
    • 
                    
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
                        GPJnCrbBdl
python开发语言
                        
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • ios GCD
                        _Waiting_

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

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

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • Python多线程实现大规模数据集高效转移
                        sand&wich
网络python服务器
                        
    背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
    
                    
    • 
                    
  • Python实现下载当前年份的谷歌影像
                        sand&wich
python开发语言
                        
    在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • vue+el-table 可输入表格使用上下键进行input框切换
                        以对_
vue学习记录vue.jsjavascript前端
                        
    使用上下键进行完工数量这一列的切换-->//键盘触发事件show(ev,index){letnewIndex;letinputAll=document.querySelectorAll('.table_inputinput');//向上=38if(ev.keyCode==38){if(index==0){//如果是第一行,回到最后一个newIndex=inputAll.length-1}elsei
    
                    
    • 
                    
  • 详解：如何设计出健壮的秒杀系统？
                        夜空_2cd3

                        
    作者：Yrion博客园：cnblogs.com/wyq178/p/11261711.html前言：秒杀系统相信很多人见过，比如京东或者淘宝的秒杀，小米手机的秒杀。那么秒杀系统的后台是如何实现的呢？我们如何设计一个秒杀系统呢？对于秒杀系统应该考虑哪些问题？如何设计出健壮的秒杀系统？本期我们就来探讨一下这个问题：image目录一：****秒杀系统应该考虑的问题二：****秒杀系统的设计和技术方案三：*
    
                    
    • 
                    
  • 经纬恒润二面&三七互娱一面&元象二面
                        Redstone Monstrosity
面试前端
                        
    1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
    
                    
    • 
                    
  • MyBatis 详解
                        阿贾克斯的黎明
javamybatis
                        
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换
                        让开，我要吃人了
OpenHarmonyHarmonyOS鸿蒙开发harmonyos华为鸿蒙移动开发鸿蒙系统前端开发语言
                        
    鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
    
                    
    • 
                    
  • vue render 函数详解 (配参数详解)
                        你的眼睛會笑
vue2vue.jsjavascript前端
                        
    vuerender函数详解(配参数详解)在Vue3中，`render`函数被用来代替Vue2中的模板语法。它接收一个h函数（或者是`createElement`函数的别名），并且返回一个虚拟DOM。render函数的语法结构如下：render(h){returnh('div',{class:'container'},'Hello,World!')}在上面的示例中，我们使用h函数创建了一个div元素
    
                    
    • 
                    
  • Redis Key的过期策略
                        ArchManual
分布式架构分布式Java后端微服务架构redis
                        
    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
    
                    
    • 
                    
  • Redis:缓存击穿
                        我的程序快快跑啊
缓存redisjava
                        
    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
    
                    
    • 
                    
  • Dockerfile命令详解之 FROM
                        清风怎不知意
容器化java前端javascript
                        
    许多同学不知道Dockerfile应该如何写，不清楚Dockerfile中的指令分别有什么意义，能达到什么样的目的，接下来我将在容器化专栏中详细的为大家解释每一个指令的含义以及用法。专栏订阅传送门https://blog.csdn.net/qq_38220908/category_11989778.html指令不区分大小写。但是，按照惯例，它们应该是大写的，以便更容易地将它们与参数区分开来。(引用
    
                    
    • 
                    
  • Dockerfile（1） - FROM 指令详解
                        小菠萝测试笔记
dockerpythonjavacmd大数据
                        
    FROM指明当前的镜像基于哪个镜像构建dockerfile必须以FROM开头，除了ARG命令可以在FROM前面FROM[--platform=][AS]FROM[--platform=][:][AS]FROM[--platform=][@][AS]小栗子FROMalpine:latest一个dockerfile可以有多个FROM可以有多个FROM来创建多个镜像，或区分构建阶段，将一个构建阶段作为另
    
                    
    • 
                    
  • 详解“c:/work/src/components/a/b.vue“‘ has no default export报错原因
                        hw_happy
开发语言前端vue.jsjavascript
                        
    前情提要在一个vue文件中需要引入定义的b.vue文件，但是提示b文件没有默认导出，对于vue2文件来说有exportdefault，在中，所有定义的变量、函数和组件都会自动被视为默认导出的组件内容。因此，不需要显式地使用exportdefault来导出组件。但是在我引用这个文件的时候还是提示了这个错误，原来是我的项目使用了ts和vite\webpack，因为TypeScript和Vue的默认导出
    
                    
    • 
                    
  • ffmpeg批量将tif文件转成jpeg格式
                        winfredzhang
图像工具ffmpegtifjpeg转换
                        
    1、cmd2、切换到安装ffmpeg的路径。3、输入命令：ffmpeg-start_number001-i"D:\ocr\%03d.tif"-start_number001-pix_fmtyuv420p-qscale:v1"D:\ocr\%03d.jpg"结果。
    
                    
    • 
                                
  • 用MiddleGenIDE工具生成hibernate的POJO（根据数据表生成POJO类）
                                    AdyZhang
POJOeclipseHibernateMiddleGenIDE
                                    
    推荐:MiddlegenIDE插件,   是一个Eclipse   插件.     用它可以直接连接到数据库,   根据表按照一定的HIBERNATE规则作出BEAN和对应的XML ，用完后你可以手动删除它加载的JAR包和XML文件!     今天开始试着使用
    
                                
    • 
                                
  • .9.png
                                    Cb123456
android
                                    
      “点九”是andriod平台的应用软件开发里的一种特殊的图片形式，文件扩展名为：.9.png 
　　智能手机中有自动横屏的功能,同一幅界面会在随着手机(或平板电脑)中的方向传感器的参数不同而改变显示的方向,在界面改变方向后,界面上的图形会因为长宽的变化而产生拉伸,造成图形的失真变形。 
　　我们都知道android平台有多种不同的分辨率，很多控件的切图文件在被放大拉伸后，边
    
                                
    • 
                                
  • 算法的效率
                                    天子之骄
算法效率复杂度最坏情况运行时间大O阶平均情况运行时间
                                    
    算法的效率 
效率是速度和空间消耗的度量。集中考虑程序的速度，也称运行时间或执行时间，用复杂度的阶(O)这一标准来衡量。空间的消耗或需求也可以用大O表示，而且它总是小于或等于时间需求。 
  
以下是我的学习笔记： 
  
1.求值与霍纳法则，即为秦九韶公式。 
  
2.测定运行时间的最可靠方法是计数对运行时间有贡献的基本操作的执行次数。运行时间与这个计数成正比。 
    
                                
    • 
                                
  • java数据结构
                                    何必如此
java数据结构
                                    
    Java 数据结构 
 
Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类： 
 
枚举（Enumeration） 
位集合（BitSet） 
向量（Vector） 
栈（Stack） 
字典（Dictionary） 
哈希表（Hashtable） 
属性（Properties） 
以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collect
    
                                
    • 
                                
  • MybatisHelloWorld
                                    3213213333332132

                                    
    
//测试入口TestMyBatis   
package com.base.helloworld.test;

import java.io.IOException;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibat
    
                                
    • 
                                
  • Java|urlrewrite|URL重写|多个参数
                                    7454103
javaxmlWeb工作
                                    
     个人工作经验！ 如有不当之处，敬请指点    
1.0  web -info 目录下建立     urlrewrite.xml  文件 类似如下： 
<?xml version="1.0" encoding="UTF-8" ?>  
  <!DOCTYPE u
    
                                
    • 
                                
  • 达梦数据库+ibatis
                                    darkranger
sqlmysqlibatisSQL Server
                                    
    --插入数据方面 
 
如果您需要数据库自增... 
那么在插入的时候不需要指定自增列. 
 
如果想自己指定ID列的值, 那么要设置 
set identity_insert  数据库名.模式名.表名; 
----然后插入数据; 
example: 
create table zhabei.test( 
id bigint identity(1,1) primary key, 
nam
    
                                
    • 
                                
  • XML 解析 四种方式
                                    aijuans
android
                                    
    XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。   
 
  
 
    
 
XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object 
    
                                
    • 
                                
  • spring中配置文件占位符的使用
                                    avords

                                    
    1.类 
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.o
    
                                
    • 
                                
  • 前端工程化-公共模块的依赖和常用的工作流
                                    bee1314
webpack
                                    
    题记： 一个人的项目，还有工程化的问题嘛？       我们在推进模块化和组件化的过程中，肯定会不断的沉淀出我们项目的模块和组件。对于这些沉淀出的模块和组件怎么管理？另外怎么依赖也是个问题？   你真的想这样嘛？       var BreadCrumb = require(‘../../../../uikit/breadcrumb’); //真心ugly。     
    
                                
    • 
                                
  • 上司说「看你每天准时下班就知道你工作量不饱和」，该如何回应？
                                    bijian1013
项目管理沟通IT职业规划
                                    
    问题：上司说「看你每天准时下班就知道你工作量不饱和」，如何回应 
        正常下班时间6点，只要是6点半前下班的，上司都认为没有加班。 
  
Eno-Bea回答，注重感受，不一定是别人的 
        虽然我不知道你具体从事什么工作与职业，但是我大概猜测，你是从事一项不太容易出现阶段性成果的工作
    
                                
    • 
                                
  • TortoiseSVN，过滤文件
                                    征客丶
SVN
                                    
    环境： 
TortoiseSVN 1.8 
 
配置： 
在文件夹空白处右键 
选择  TortoiseSVN -> Settings 
在 Global ignote pattern 中添加要过滤的文件： 
多类型用英文空格分开 
*name ： 过滤所有名称为 name 的文件或文件夹 
*.name ： 过滤所有后缀为 name 的文件或文件夹 
 
 
 
--------
    
                                
    • 
                                
  • 【Flume二】HDFS sink细说
                                    bit1129
Flume
                                    
    1. Flume配置 
  
a1.sources=r1  
a1.channels=c1  
a1.sinks=k1  

###Flume负责启动44444端口
  
a1.sources.r1.type=avro  
a1.sources.r1.bind=0.0.0.0  
a1.sources.r1.port=44444  
a1.sources.r1.chan
    
                                
    • 
                                
  • The Eight Myths of Erlang Performance
                                    bookjovi
erlang
                                    
    erlang有一篇guide很有意思： http://www.erlang.org/doc/efficiency_guide 
里面有个The Eight Myths of Erlang Performance： http://www.erlang.org/doc/efficiency_guide/myths.html 
  
  
Myth: Funs are sl
    
                                
    • 
                                
  • java多线程网络传输文件(非同步)-2008-08-17
                                    ljy325
java多线程socket
                                    
    利用 Socket 套接字进行面向连接通信的编程。客户端读取本地文件并发送；服务器接收文件并保存到本地文件系统中。 
使用说明:请将TransferClient, TransferServer, TempFile三个类编译，他们的类包是FileServer. 
客户端: 
修改TransferClient: serPort, serIP, filePath, blockNum,的值来符合您机器的系
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-模板方法模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
    
                                
    • 
                                
  • 配置心得
                                    chenyu19891124
配置
                                    
    时间就这样不知不觉的走过了一个春夏秋冬，转眼间来公司已经一年了，感觉时间过的很快，时间老人总是这样不停走，从来没停歇过。 
作为一名新手的配置管理员，刚开始真的是对配置管理是一点不懂，就只听说咱们公司配置主要是负责升级，而具体该怎么做却一点都不了解。经过老员工的一点点讲解，慢慢的对配置有了初步了解，对自己所在的岗位也慢慢的了解。 
做了一年的配置管理给自总结下： 
1.改变 
从一个以前对配置毫无
    
                                
    • 
                                
  • 对“带条件选择的并行汇聚路由问题”的再思考
                                    comsci
算法工作软件测试嵌入式领域模型
                                    
    2008年上半年，我在设计并开发基于”JWFD流程系统“的商业化改进型引擎的时候，由于采用了新的嵌入式公式模块而导致出现“带条件选择的并行汇聚路由问题”(请参考2009-02-27博文)，当时对这个问题的解决办法是采用基于拓扑结构的处理思想，对汇聚点的实际前驱分支节点通过算法预测出来，然后进行处理，简单的说就是找到造成这个汇聚模型的分支起点，对这个起始分支节点实际走的路径数进行计算，然后把这个实际
    
                                
    • 
                                
  • Oracle 10g 的clusterware 32位 下载地址
                                    daizj
oracle
                                    
    Oracle 10g 的clusterware 32位 下载地址 
 
http://pan.baidu.com/share/link?shareid=531580&uk=421021908 
 
 
http://pan.baidu.com/share/link?shareid=137223&uk=321552738 
 
http://pan.baidu.com/share/l
    
                                
    • 
                                
  • 非常好的介绍：Linux定时执行工具cron
                                    dongwei_6688
linux
                                    
    Linux经过十多年的发展，很多用户都很了解Linux了，这里介绍一下Linux下cron的理解，和大家讨论讨论。cron是一个Linux 定时执行工具，可以在无需人工干预的情况下运行作业，本文档不讲cron实现原理，主要讲一下Linux定时执行工具cron的具体使用及简单介绍。 
新增调度任务推荐使用crontab -e命令添加自定义的任务（编辑的是/var/spool/cron下对应用户的cr
    
                                
    • 
                                
  • Yii assets目录生成及修改
                                    dcj3sjt126com
yii
                                    
    assets的作用是方便模块化，插件化的，一般来说出于安全原因不允许通过url访问protected下面的文件，但是我们又希望将module单独出来，所以需要使用发布，即将一个目录下的文件复制一份到assets下面方便通过url访问。 
assets设置对应的方法位置 \framework\web\CAssetManager.php 
  
assets配置方法 在m
    
                                
    • 
                                
  • mac工作软件推荐
                                    dcj3sjt126com
mac
                                    
    mac上的Terminal + bash ＋ screen组合现在已经非常好用了，但是还是经不起iterm＋zsh＋tmux的冲击。在同事的强烈推荐下，趁着升级mac系统的机会，顺便也切换到iterm＋zsh＋tmux的环境下了。 
我为什么要要iterm2 
切换过来也是脑袋一热的冲动，我也调查过一些资料，看了下iterm的一些优点： 
 
 * 兼容性好，远程服务器 vi 什么的低版本能很好兼
    
                                
    • 
                                
  • Memcached(三)、封装Memcached和Ehcache
                                    frank1234
memcachedehcachespring ioc
                                    
    本文对Ehcache和Memcached进行了简单的封装，这样对于客户端程序无需了解ehcache和memcached的差异，仅需要配置缓存的Provider类就可以在二者之间进行切换，Provider实现类通过Spring IoC注入。 
cache.xml 
 
<?xml version="1.0" encoding="UTF-8"?>

    
                                
    • 
                                
  • Remove Duplicates from Sorted List II
                                    hcx2013
remove
                                    
    Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. 
For example,Given 1->2->3->3->4->4->5,
    
                                
    • 
                                
  • Spring4新特性——注解、脚本、任务、MVC等其他特性改进
                                    jinnianshilongnian
spring4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • MySQL安装文档
                                    liyong0802
mysql
                                    
      工作中用到的MySQL可能安装在两种操作系统中，即Windows系统和Linux系统。以Linux系统中情况居多。 
  安装在Windows系统时与其它Windows应用程序相同按照安装向导一直下一步就即，这里就不具体介绍，本文档只介绍Linux系统下MySQL的安装步骤。 
  Linux系统下安装MySQL分为三种：RPM包安装、二进制包安装和源码包安装。二
    
                                
    • 
                                
  • 使用VS2010构建HotSpot工程
                                    p2p2500
HotSpotOpenJDKVS2010
                                    
    1. 下载OpenJDK7的源码： 
     
http://download.java.net/openjdk/jdk7 
     
http://download.java.net/openjdk/ 
     
2. 环境配置 
    ▶
    
                                
    • 
                                
  • Oracle实用功能之分组后列合并
                                    seandeng888
oracle分组实用功能合并
                                    
    1       实例解析  
由于业务需求需要对表中的数据进行分组后进行合并的处理，鉴于Oracle10g没有现成的函数实现该功能，且该功能如若用JAVA代码实现会比较复杂，因此，特将SQL语言的实现方式分享出来，希望对大家有所帮助。如下： 
表test 数据如下： 
ID,SUBJECTCODE,DIMCODE,VALUE 
1&nbs
    
                                
    • 
                                
  • Java定时任务注解方式实现
                                    tuoni
javaspringjvmxmljni
                                    
    Spring 注解的定时任务，有如下两种方式： 
第一种： 
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

 xmlns:xsi="http
    
                                
    • 
                                
  • 11大Java开源中文分词器的使用方法和分词效果对比
                                    yangshangchuan
word分词器ansj分词器Stanford分词器FudanNLP分词器HanLP分词器
                                    
    本文的目标有两个： 
1、学会使用11大Java开源中文分词器 
2、对比分析11大Java开源中文分词器的分词效果 
本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。 
11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： 
/**
 * 获取文本的所有分词结果, 对比
    
                                
    •