在不指定线程的情况下, RxJava 遵循的是线程不变的原则,即:在哪个线程调用 subscribe(),就在哪个线程生产事件;在哪个线程生产事件,就在哪个线程消费事件。如果需要切换线程,就需要用到 Scheduler (调度器)。1) Scheduler 的 API (一)在RxJava 中,Scheduler ——调度器,相当于线程控制器,RxJava 通过它来指定每一段代码应该运行在什么样的            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-27 14:39:20
                            
                                94阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            在不指定线程的情况下, RxJava 遵循的是线程不变的原则,即:在哪个线程调用 subscribe(),就在哪个线程生产事件;在哪个线程生产事件,就在哪个线程消费事件。想要在RxJava中引入多线程的功能,可以使用一些操作符使得RxJava在指定的线程上运行,即实现线程的切换功能。比如说一些耗时的操作,如我们看电影,一个线程在后台下载数据,然后播放视频在当前的线程,这样就可以给我们更好            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-21 00:28:17
                            
                                112阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            目录
自己动手造一个 RxJava 序言目录1.理解临时任务对象
场景 
同步 
异步 
泛型回调 
临时任务对象 
组装任务 
改装流水线 
简单的映射 2.事件的发送与接收RxJava 的发送和接收原理事件发送接收
操作符 just 的实现 
3.映射 4.线程调度subscribeOn 的实现observeOn 的实现利用线程池进行调度关闭线程池
结语 4.线程调度终于来到最后一个 part            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-10-31 00:00:07
                            
                                71阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            RxJava 的大名不需要多做介绍,我自己也在项目中使用RxJava也有一段时间了,抱着学习的心态,一直想更深入一点的去了解它的实现原理,当然RxJava东西还是蛮多的,不可能一篇文章就能说清楚,so,这肯定是一个系列,在这一篇,我先尝试从 RxJava的线程控制 来切入,管中窥豹吧,我尽力,看官们随意。最简单的使用从我们日常使用的代码入手,可能能更容易理解一点。Observable.create            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-23 13:16:43
                            
                                43阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            RxJava 线程池线程控制——SchedulerRxJava中的多线程操作主要是由Scheduler集合提供的。在RxJava中,我们无法直接访问或操作线程。如果想要使用线程的话,必须要通过内置的Scheduler来实现。在RxJava 中,Scheduler ——调度器,相当于线程控制器,RxJava 通过它来指定每一段代码应该运行在什么样的线程。RxJava 已经内置了几个 Schedule            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-05 12:12:29
                            
                                86阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            Learning RxJava(RxJava详解)为什么做这个项目: 学习Rxjava,基本所有人都会看扔物线的《给Android开发者Rxjava的详解》,可以说是国内最理想的Rxjava教程了。这片文章后半部分讲对线程的操作,相信很多人都不太懂。这个项目通过最简单的方式,对Rxjava线程操作的进行讲解,让大家彻底明白Rxjava的核心内容。所以,在学习这个项目前先看扔物线大哥的文章。RxJa            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-11 07:24:24
                            
                                123阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            本文为大家分析四种Java线程池用法,供大家参考,具体内容如下1、new Thread的弊端执行一个异步任务你还只是如下new Thread吗?new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
}
).start();那你就out太多了,new Thread的            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-07-10 21:45:03
                            
                                12阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            RxJava 线程控制RxJava 可以切换调度线程,控制每个操作在哪个线程执行。RxJava 内置的 Scheduler如果我们不指定线程,默认是在调用 subscribe 方法的线程上进行回调的。如果想切换线程,就需要使用调度器(Scheduler)。RxJava 内置了如下 5 个 Scheduler。Schedulers.immediate:直接在当前线程运行,它是 timeout、tim            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-05-18 19:33:47
                            
                                932阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            RxJava概念RxJava是一个在Java VM上使用可观测的序列来组成异步的、基于事件的程序库。  RxJava的异步实现,是通过一种扩展的观察者模式来实现的。这也是基于“响应式编程”的概念。在RxJava的观察者模式中,如果没有观察者,被观察者不会发出事件的。RxJava相对于AsyncTask 和Handler,优势在于随着程序逻辑变得愈加复杂,依旧可以保持简洁。RxJava名词解释map            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-01-10 17:56:57
                            
                                16阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            概述本文将分析下rxjava线程池相关的源码。 本文的内容大概有以下:Schedulers.io()源码线程工厂RxThreadFactory源码线程池CachedWorkerPool源码Worker的创建与调用Schedulers.io()源码rxjava内置的线程池除了io,还有newThead,single等,它们的逻辑都是类似的,本文就以io为例子来进行解析。demo代码:Observab            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-22 20:47:19
                            
                                194阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            前言一、我认为一点就通的原理如果大家理解了subscribeOn的原理,那么observeOn就非常好理解了。我们这样想,subscribeOn既然是在“从下往上”调用的过程中“做手脚”,即控制上层的执行线程,那么observeOn就是“从上往下”调用的过程中做手脚啦,只不过subscribeOn因为其特殊的设计导致其只有在第一次调用时才有效,而observeOn却可以多次切换其后代码的执行线程,            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-15 19:44:06
                            
                                72阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            1. 创建线程池和线程管理策略分析// 在开发中使用Rxjava来完成线程切换会调用到以下方法(还有几个就不一一列举了,原理一样的),那么就从这里开始分析Schedulers.io()
Schedulers.computation()
Schedulers.newThread()
AndroidSchedulers.mainThread()当我们调用以上方法中的任意一个,都会调到Scheduler            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-14 15:49:41
                            
                                193阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            前言在上篇文章对RxJava 的工作流程进行的简单的分析,今天来分享一下线程切换的流程。如果觉得源码枯燥可以直接移至文末看图理解。实例代码Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(@NonNull Obse            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-22 11:11:17
                            
                                43阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            前言经过前几篇的介绍,对RxJava对模式有了一定的理解:由Observable发起事件,经过中间的处理后由Observer消费。(对RxJava还不了解的可以出门左拐) 之前的代码中,事件的发起和消费都是在同一个线程中执行,也就是说之前我们使用的RxJava是同步的~~~ 观察者模式本身的目的不就是后台处理,将处理结果回调给前台?这同步的是要哪样?所以,这篇为大家介绍RxJava的重要的概念——            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-25 07:17:10
                            
                                46阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            在上一篇我们只是简单的介绍RxJava的订阅和事件流,这一篇我们要分析的是RxJava最流弊的地方:线程切换。相信使用过RxJava的人都会被它优雅的线程操作所折服,好了不废话了,我们先说一下本文的重点:  (1)subscribeOn是如何实现的,它是如何影响事件流的,如果我们使用多次会是什么结果,为什么?  (2)observeOn是如何实现的,它是如何影响事件流的,如果我们使用多次会是什么结            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-05 12:55:32
                            
                                47阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            1) Scheduler 的 API (一)在RxJava 中,Scheduler ——调度器,相当于线程控制器,RxJava 通过它来指定每一段代码应该运行在什么样的线程。RxJava 已经内置了几个 Scheduler ,它们已经适合大多数的使用场景:
Schedulers.immediate(): 直接在当前线程运行,相当于不指定线程。这是默认的 Sc            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-06 13:50:19
                            
                                166阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            RxJava切换线程是怎么实现的呢?lift变换过程要明白 RxJava 切换线程切换线程的原理,我们首先得理解变换过程。  对于变换过程,我的理解就是:Observable.create(new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? s            
                
         
            
            
            
            RxJava 比较方便的一点在于线程间的切换,我们可以从上往下下,并且随时实现线程的切换,看个简单的代码 private static void initRxJava1(){
        Observable
                .create(new Observable.OnSubscribe<String>() {            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-02-21 14:44:49
                            
                                35阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            RxJava2 源码分析笔记(一)RxJava2 源码分析笔记(二)终于来到线程切换先看一个如何切线程的简略流程图注: 上面蓝色主流程中  subscribeOn(Schedulers.io()) ,observeOn(AndroidSchedulers.mainThread()) 但是subscribeOn,observeOn他们即可以传主线程也可以传子线程               
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-10-12 11:36:53
                            
                                112阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            Rxjava2实战--第四章 Rxjava的线程操作1 调度器(Scheduler)种类1.1 RxJava线程介绍默认情况下,1.2 SchedulerSheduler作用single使用定长为1的线程池(new ScheduledThread Pool(1)),重复利用这个线程newThread每次都启用线程,并 在新线程中执行操作computation使用固定的线程池(Fixed Sched            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-05 00:14:17
                            
                                91阅读