rxjava源码中的线程知识

rxjava源码中的线程知识

rx的最精简的总结就是：异步

这里说一下以下的五个类

1.Future
2.ConcurrentLinkedQueue
3.volatile关键字
4.AtomicReference
5.ScheduledExecutorService

一.Future类

1.Future的唯一实现类是FutureTask。
    
    2.这样就可以把Callable放到FutureTask。然后用FutureTask可以Thread thread = new Thread(futureTask)放到thread。
    FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
    
    4.Callable就是比runable多了个返回值。

作用

　    1）判断任务是否完成；
　    2）能够中断任务；
　    3）能够获取任务执行结果。
    
    
    public void test(){
         ExecutorService executor = Executors.newCachedThreadPool();创建一个线程池
            Task task = new Task();创建一个Callable
            Future<Integer> result = executor.submit(task);Callable注册一下
            executor.shutdown();挂起线程池
             
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
             
            System.out.println("主线程在执行任务");
             
            try {
                System.out.println("task运行结果"+result.get());//获取线程结果，阻塞的
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
             
            System.out.println("所有任务执行完毕");
        }

class Task implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("子线程在进行计算");
            Thread.sleep(3000);
            int sum = 0;
            for(int i=0;i<100;i++)
                sum += i;
            return sum;
        }
    }
    
二.ScheduledExecutorService类
    ScheduledExecutorService类继承ExecutorService，定时线程池。可以执行Callable和runable。
    常用三个方法
    1.schedule(task,initDelay):安排所提交的Callable或Runnable任务在initDelay指定的时间后执行。
    2.scheduleAtFixedRate()：安排所提交的Runnable任务按指定的间隔重复执行
    3.scheduleWithFixedDelay()：安排所提交的Runnable任务在每次执行完后，等待delay所指定的时间后重复执行。

这个类比较简单，不举例说明了
    
    
三.ConcurrentLinkedQueue类
    ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列
    
    这篇文章已经写得很详细了http://www.infoq.com/cn/articles/ConcurrentLinkedQueue/

四.volatile关键字，易失性变量    
 volatile和synchronized是实现线程安全的，volatile 变量可以被看作是一种 “程度较轻的 synchronized，Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性.
 
 使用volatile要具备以下两个条件，例如i++这种事不适用的。
    1.对变量的写操作不依赖于当前值。
    2.该变量没有包含在具有其他变量的不变式中。
    
详细请查看：http://www.ibm.com/developerworks/cn/java/j-jtp06197.html

五.AtomicReference

AtomicReference的实现其实就是=volatile+cas，这是我的粗略见解
    首先volatile是有可见性的，但是没有原子性，这样子对变量的写操作必须不依赖于当前值，如果依赖了当前值怎么办，好了这里就加入了cas操作，可以先判断先判断变量是否被其他线程操作过，再进行更新赋值。当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入。这样就不会中断线程。
    
     AtomicReference函数列表

使用 null 初始值创建新的 AtomicReference。
    AtomicReference()
    使用给定的初始值创建新的 AtomicReference。
    AtomicReference(V initialValue)

如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
    boolean compareAndSet(V expect, V update)
    // 获取当前值。
    V get()
    以原子方式设置为给定值，并返回旧值。
    V getAndSet(V newValue)
    最终设置为给定值。
    void lazySet(V newValue)
    设置为给定值。
    void set(V newValue)
    返回当前值的字符串表示形式。
    String toString()
    如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
    boolean weakCompareAndSet(V expect, V update)