线程和进程的关系？

多线程

原子性、可见性、有序性

1.ThreadLocal

数据隔离

2.volatile

3.CAS

synchronized

数据共享

RxJava原理和优点？

Java有几种引用？

强引用>软引用>弱引用>虚引用

除了强引用，其它的引用对象内存都可能被GC回收

• 强引用

  强引用可以直接访问目标对象。 强引用所指向的对象在任何时候都不会被系统回收。JVM宁愿抛出OOM异常，也不会回收强引用所指向的对象。 强引用可能导致内存泄露。

• 软引用

  可以通过java.lang.ref.SoftReference使用软引用。一个持有软引用的对象，不会被JVM很快回收，JVM会根据当前堆的使用情况来判断何时回收。当堆的使用率临近阈值时，才会回收软引用的对象。

  需要注意的是，在垃圾回收器对这个Java对象回收前，SoftReference类所提供的get方法会返回Java对象的强引用，一旦垃圾线程回收该Java对象之后，get方法将返回null。所以在获取软引用对象的代码中，一定要判断是否为null，以免出现NullPointerException异常导致应用崩溃。

  如果只是想避免OutOfMemory异常的发生，则可以使用软引用。

• 弱引用

  弱引用是一种比软引用较弱的引用类型。在系统GC时，只要发现弱引用，不管系统堆空间是否足够，都会将对象进行回收。但是，由于垃圾回收器的线程通常优先级很低，因此，并一不定能很快的发现持有弱引用的对象。这种情况下，弱引用对象可以存在较长的一段时间。一旦一个弱引用对象被垃圾回收器回收，便会加入到一个注册引用队列中。

  如果对于应用的性能更在意，想尽快回收一些占用内存比较大的对象，则可以使用弱引用。

  软引用，弱引用都非常适合来保存那些可有可无的缓存数据。如果这样做，当系统内存不足时，这些缓存数据会被回收，不会导致内存溢出。而当内存资源充足时，这些缓存数据又可以存在相当长的时间。

• 虚引用

虚引用是所有引用类型中最弱的一个。一个持有虚引用的对象，和没有引用几乎是一样的，随时都可能被垃圾回收器回收。当试图通过虚引用的get()方法取得强引用时，总是会失败。并且，虚引用必须和引用队列一起使用，它的作用在于跟踪垃圾回收过程。 当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在垃圾回收后，销毁这个对象，奖这个虚引用加入引用队列。

内部类

• 成员内部类

注意内存泄漏的发生

• 匿名内部类

注意内存泄漏的发生

• 静态内部类

往往用来解决非静态内部类内存泄漏的问题

• 局部内部类

注意内存泄漏的发生

接口和内部类

• 如果多个接口具有相同的方法，可以用内部类来避免重名方法的多继承，即内部类来实现接口的方法，重新暴露该方法。

JVM

• JVM内存模型
• JVM调优

编写线程安全的单例

• Lazy

   /**
     * Usage
     * SingletonLazy.getInstance();
     */
    public class SingletonLazy
    {
        //必须volatile禁止指令重排，保证内存可见性。
        private static volatile SingletonLazy instance = null;
  
        private SingletonLazy() {}
  
        public  static SingletonLazy getInstance()
        {
            if (instance == null)
            {
                synchronized (SingletonLazy.class)
                {
                    //再次检查是因为多线程环境下可能多次创建对象
                    if (instance == null) //double check for multiple threads
                    {
                        instance = new SingletonLazy();//because new Singleton1() is not atomic op
                    }
                }
            }
            return instance;
        }
    }
  
  

• Eager

   /**
     * Usage
     * SingletonEager.getInstance();
     * 弱点是只要类加载就会初始化该单例对象，对于大对象不理想。
     */
    public class SingletonEager
    {
        //One instance always exists
        private static SingletonEager instance = new SingletonEager();
        private SingletonEager() {}
        public static SingletonEager getInstance()
        {
            return instance;
        }
    }
  

• Static Inner Class

   /**
     * Usage:
     * SingletonWithStaticHolder.getInstance();
     */
    public class  SingletonWithStaticHolder
    {
        private SingletonWithStaticHolder() {}
        //延迟加载，只有引用到该静态内时才创建
        private static class SingletonHolder {
            private static SingletonWithStaticHolder instance = new SingletonWithStaticHolder();
        }
        public static SingletonWithStaticHolder getInstance()
        {
            return SingletonHolder.instance;
        }
    }
  

• Enum 推荐做法

    public static class Camera
    {
  
    }
     /**
     *  Usage:
     *  SingletonEnum.INSTANCE.getCamera();
     */
    public enum SingletonEnum {
        INSTANCE;
        private Camera camera = null;
        private SingletonEnum()
        {
            camera = new Camera();
        }
  
        public Camera getCamera()
        {
            return camera;
        }
    }
  

CAS

三个参数，一个当前内存值V、旧的预期值A、即将更新的值B，当且仅当预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。

AtomicStampedReference

通过控制变量值的版本来保证CAS的正确性，解决ABA问题

COW(Copy on write)

是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet。CopyOnWrite容器非常有用，可以在非常多的并发场景中使用到。

1. CopyOnWrite容器

CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

设计模式

单例模式

简单工厂(静态工厂)

抽象工厂

Builder

Adapter

Proxy

Medidator

Observer

对象的equals等价关系

• 自反性

对于任何非null的引用值x,x.equals(x)必须返回true

• 对称性

对于任何的非null引用值x和y,当且仅当x.equals(y)返回true时,y.equals(x)必须返回true

• 传递性

对于任何非null的引用值x,y,z,如果x.equals(y)返回true并且y.equals(z)也返回true，那么x.equals(z)必须返回true

• 一致性

对于任何非null的引用值x,y,只要equals的比较操作在对象中所用的信息没有发生改变，多次调用x.equals(y)就会一致的返回true或false。

• 非空性

对于任何的非null的引用值x，x.equals(null)必须返回false