自己动手线程调度切换之子线程切换

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_24675479/article/details/79826386

使用

 Observable.just("http://d.paper.i4.cn/max/2016/10/10/15/1476085552237_716159.jpg")
                .map(new Function<String, Bitmap>() {
                    @Override
                    public Bitmap apply(@NonNull String s) throws Exception {
                        URL url = new URL("http://d.paper.i4.cn/max/2016/10/10/15/1476085552237_716159.jpg");
                        HttpURLConnection httpsURLConnection = (HttpURLConnection) url.openConnection();
                        httpsURLConnection.connect();
                        InputStream inputStream = httpsURLConnection.getInputStream();
                        Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
                        return bitmap;
                    }
                }).map(new Function<Bitmap, Bitmap>() {
            @Override
            public Bitmap apply(@NonNull Bitmap bitmap) throws Exception {
                bitmap = createWatermark(bitmap, "rxjava");
                return bitmap;
            }
        }).subscribeOn(Schedulers.io())
                .subscribe(new Consumer<Bitmap>() {
                    @Override
                    public void onNext(Bitmap bitmap) throws Exception {
                        // mImage.setImageBitmap(bitmap);
                    }
                });
    }

猜测.subscribeOn(Schedulers.io())是一个runnable和线程池切换

源码分析

Schedulers.io()源码分析

 public static Scheduler io() {
        return RxJavaPlugins.onIoScheduler(IO);
    }
     IO = RxJavaPlugins.initIoScheduler(new IOTask());
    static final class IOTask implements Callable<Scheduler> {
        @Override
         //实际是new了一个IoScheduler
            return IoHolder.DEFAULT;
        }

    public IoScheduler() {
         //这个方式实际就是new一个线程池和其他参数
        this(WORKER_THREAD_FACTORY);
    }

subscribeOn源码分析

 public final Observable<T> subscribeOn(Scheduler scheduler) {
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        //ObservableSubscribeOn对象，实际还是继承于Observable对象，this上游
        return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
    }

还是会复写改方法

    @Override
    public void subscribeActual(final Observer<? super T> s) {
         //下游
         final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
         //调用onSubscribe方法
        s.onSubscribe(parent);
        //new SubscribeTask(parent)实际是runnable对象
        //scheduler.scheduleDirect(runnable)
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }

new SubscribeTask(parent)源码分析

 final class SubscribeTask implements Runnable {
        private final SubscribeOnObserver<T> parent;

        SubscribeTask(SubscribeOnObserver<T> parent) {
            this.parent = parent;
        }

        @Override
        public void run() {
        //上游调用下游的观察
            source.subscribe(parent);
        }
    }

scheduler.scheduleDirect(runnable)源码分析

    public Disposable scheduleDirect(@NonNull Runnable run) {
    //0代表没有延时
        return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    }
    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
       //看下发现是抽象方法,我们传的是IO,所以看IOSchedular,实际就是一个线程池等一些
        final Worker w = createWorker();

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
        //将run和线程池封装
        DisposeTask task = new DisposeTask(decoratedRun, w);
         //实际还是调用的是IOSchedular中的方法
        w.schedule(task, delay, unit);

        return task;
    }

createWorker源码分析

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

 EventLoopWorker(CachedWorkerPool pool) {
             //线程池
            this.pool = pool;
             this.tasks = new CompositeDisposable();
            this.threadWorker = pool.get();
        }

schedule源码分析

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

 public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
        Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
       //decoratedRun自己传的run  parent实际是task
        ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

        if (parent != null) {
            if (!parent.add(sr)) {
                return sr;
            }
        }

        Future<?> f;
        try {
            if (delayTime <= 0) {
               //线程池执行,这个点击进去会发现是个抽象方法，这时候看executor，找实现类
                f = executor.submit((Callable<Object>)sr);
            } else {
                f = executor.schedule((Callable<Object>)sr, delayTime, unit);
            }
            sr.setFuture(f);
        } catch (RejectedExecutionException ex) {
            if (parent != null) {
                parent.remove(sr);
            }
            RxJavaPlugins.onError(ex);
        }

        return sr;
    }

   //new一个
  executor = SchedulerPoolFactory.create(threadFactory);
   public static ScheduledExecutorService create(ThreadFactory factory) {
     //只有这个方法可以看，最后会进入到ScheduledThreadPoolExecutor
        final ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, factory);
        if (PURGE_ENABLED && exec instanceof ScheduledThreadPoolExecutor) {
            ScheduledThreadPoolExecutor e = (ScheduledThreadPoolExecutor) exec;
            POOLS.put(e, exec);
        }
        //实际返回的是ScheduledExecutorService 
        return exec;
    }

ScheduledThreadPoolExecutor源码分析

   //找到实现类了，然后找submit
    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue(), threadFactory);
    }

submit源码分析

  public Future<?> submit(Runnable task) {
        return schedule(task, 0, NANOSECONDS);
    }
  public ScheduledFuture<?> schedule(Runnable command,
                                       long delay,
                                       TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        RunnableScheduledFuture<Void> t = decorateTask(command,
            new ScheduledFutureTask<Void>(command, null,
                                          triggerTime(delay, unit),
                                          sequencer.getAndIncrement()));
        delayedExecute(t);
        return t;
    }

delayedExecute源码分析

    private void delayedExecute(RunnableScheduledFuture<?> task) {
        if (isShutdown())
            reject(task);
        else {
            super.getQueue().add(task);
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }

看execute方法

//会发现submit和execute的方法执行的是同一个方法
  public void execute(Runnable command) {
        schedule(command, 0, NANOSECONDS);
    }

实际最终就是用线程池去调用线程方法

扫描二维码关注公众号，回复： 2987132 查看本文章

自己动手写

基于上两篇文章进行修改
observerable新增subscribeOn方法

   public  Observable<T> subscribeOn(Schedulers schedulers){
        return onAssembly(new ObservableSchedulers(this,schedulers));
    }

ObservableSchedulers方法

public class ObservableSchedulers<T> extends Observable<T> {
    Observable<T> source;
    Schedulers schedulers;
    public ObservableSchedulers(Observable<T> source, Schedulers schedulers) {
        this.source=source;
        this.schedulers=schedulers;
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        //相当于线程池执行
        schedulers.scheduleDirect(new SchedulerTask(observer));
    }


    private class SchedulerTask implements Runnable {
        Observer<? super T> observer;
        public SchedulerTask(Observer<? super T> observer) {
            this.observer=observer;
        }

        @Override
        public void run() {
            // 而这个run方法在子线程中
            source.subscribe(observer);
        }
    }
}

Schedulers代码

public abstract class Schedulers {
    static Schedulers IO;
    static {
        IO=new IOSchedulers();
    }
    public static Schedulers io() {
          return IO;
    }

    public abstract void scheduleDirect(Runnable runnable);


    private static class IOSchedulers extends Schedulers {
        ExecutorService service;
        public IOSchedulers(){
            service= Executors.newScheduledThreadPool(1, new ThreadFactory() {
                @Override
                public Thread newThread(@NonNull Runnable r) {
                    return new Thread(r,"IOSchedulers");
                }
            });
        }
        @Override
        public void scheduleDirect(Runnable runnable) {
             service.execute(runnable);
        }
    }
}