Android 面试题总结(二)

前言

• 笔者最近离职找工作快两周了,这段时间陆陆续续也见识了北上广这边跟西部城市对待技术理念的差异和学习深度.俗话说:知耻而后勇,在经历了面试被虐得体无完肤的过程后,我也找到了作为一名开发者应有的职业素养和今年的发展规划.
• 俗话也说的好,王侯将相宁有种乎,我不信我从今天开始认认真真对待每一个技术细节,认真刷题.,在深圳这座城市没有我的立足之地.
• 好了,鸡汤和废话也不多说了,依旧记录今日面试的题目.

正文

1. Android内存泄露的解决方案:
   http://blog.csdn.net/Huang_Cai_Yuan/article/details/50443385
   http://my.oschina.net/rengwuxian/blog/181449
   含义:一个对象已经不需要再使用了,但是因为其他的对象持有该对象的引用,导致它的内存不能被回收.
   危害:只有一个,那就是虚拟机占用内存过高,导致OOM(内存溢出),程序出错.
   内存泄露的主要问题可以分为以下几种类型:
   1.静态变量引起的内存泄露:
   在java中静态变量的生命周期是在类加载时开始,类卸载时结束.换句话说,在android中其生命周期是在进程启动时开始,进程死亡时结束.所以在程序的运行期间,如果进程没有被杀死,静态变量就会一直存在,不会被回收掉.如果静态变量强引用了某个Activity中变量,那么这个activity就同样也不会被释放,即便是该activity执行了onDestroy.
   解决方案:
   1.寻找与该静态变量生命周期差不多的替代对象.
   2.若找不到,将强引用方式改成弱引用.
   案例:单例引起的context内存泄露

public static IMManager getInstance(Context context) {
        if (mInstance == null) {
            synchronized (IMManager.class) {
                if (mInstance == null)
                    mInstance = new IMManager(context);
            }
        }
        return mInstance;
    }

当调用getInstance时，如果传入的context是Activity的context。只要这个单例没有被释放，这个Activity也不会被释放。
解决方案:传入Application的context.
2.非静态内部类引起的内存泄露:
在java中,创建一个非静态的内部类实例,就会引用它的外围实例.如果这个非静态内部类实例做了一些耗时的操作.就会造成外围对象不会被回收,从而导致内存泄露.
解决方案:
1.将内部类变成静态内部类
当将内部类变成静态内部类后,便不再持有外部类对象的引用,导致程序不允许你在handler中操作activity的对象了,因此我么需要在handler中增加一个对A/ctivity的弱引用(WeakReference);
注:为什么使用静态内部类就不会造成内存泄露了?
答:静态内部类不会持有对外部对象的引用
2.如果有强引用Activity中的属性,则将该属性的引用方式改为弱引用.
使用WeakReference包装该对象.
3.在业务允许的情况下,当activity执行onDestory时,结束这些耗时任务

static class MyHandler extends Handler {
    WeakReference<Activity > mActivityReference;

    MyHandler(Activity activity) {
        mActivityReference= new WeakReference<Activity>(activity);
    }

    @Override
    public void handleMessage(Message msg) {
        final Activity activity = mActivityReference.get();
        if (activity != null) {
            mImageView.setImageBitmap(mBitmap);
        }
    }
}

3.资源未关闭引起的内存泄露
当使用了BroadcastReceiver\Cursor\Bitmap等资源的时候,当不需要使用时,需要及时释放掉,若没有释放,则会引起内存泄露.

4.**增加:在使用Bitmap时,出现内存溢出的解决方案:**1.调用系统的GC回收,System.gc();2.压缩图片质量大小.

小结

虽然静态类与非静态类之间的区别并不大,但是对于Android开发者而言却是必须理解的.至少我们要清楚,如果一个内部类实例的生命周期比Activity更长,那么我们千万不要使用非静态的内部类.最好的做法是,使用静态内部类,然后在该类里面使用弱引用来指向所在的Activity

2.Java基础之弱引用\强引用\软引用\虚引用:
http://blog.csdn.net/mazhimazh/article/details/19752475这里写链接内容
强引用(StrongReference):是使用最普遍的引用.如果一个对象具有强引用,那GC回收器绝不会回收它.

    Object o=new Object();   //  强引用  
    public void test(){  
        Object o=new Object();  
        // 省略其他操作  
    }  

当内存不足时,java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题.如果不使用时,要通过如下方式来弱化引用.

在方法内部有一个强引用,这个引用保存在栈中,而真正得引用内容(Object )保存在堆中.当这个方法运行完成后,就会推出方法栈,则引用内容的引用不存在,这个Object会被回收.

但是如果这个o是全局的变量时,就需要在不用这个对象时复制为null,因为强引用不会被垃圾回收。
软引用(SoftReference): 如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

    String str=new String("abc");                                     // 强引用  
    SoftReference<String> softRef=new SoftReference<String>(str);     // 软引用    

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
弱引用:
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

    String str=new String("abc");      
    WeakReference<String> abcWeakRef = new WeakReference<String>(str);  
    str=null;    

当你想引用一个对象，但是这个对象有自己的生命周期，你不想介入这个对象的生命周期，这时候你就是用弱引用。
虚引用（PhantomReference）:
“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中。

3.Java中static,final等关键字:
http://blog.csdn.net/mazhimazh/article/details/16805061
static关键字:
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
1.static修饰方法:
当static关键字修饰方法时，这个方法就称为静态方法。静态方法属于类而不属于实例对象。那么静态方法如何进行调用？可以通过类名.方法名来直接调用，也可以通过实例对象.方法名来调用。
使用static关键字修饰的方法在类加载的时候就会加载到内存中。是被指向所属的类而不是实例。
可以看出，这并不是覆盖，其实静态方法只可以被隐藏，而不可以覆盖。当t1为Person类型时，则调用Person类的静态方法，因为静态方法只属于这个类，而当t2类型为Test02时，调用子类的静态方法，当子类没有时，调用父类的方法，这就叫做继承父类的方法了。
2.static修改属性:
当static修饰属性时，与类一样，都是在类加载时就加载到了内存。
3.static修饰块
加static修饰的块也会随着类的加载而进入内存，所以可以在这里初始化一些静态成员变量。
4.使用static注意事项:
当类被虚拟机加载时，按照声明顺序先后初始化static成员字段和static语句块
static所修饰的方法和变量只属于类，所有对象共享。
在static所修饰的方法和语句块中不能使用非static成员字段。
静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，把“全局变量”放在内部类中就是毫无意义的事情，所以 被禁止
在Java不能直接定义全局变量，是通过static来实现的
在Java中没有const，不能直接定义常量，通过static final来实现
final 关键字:
1.final关键字的使用:引用本身的不变和引用指向的对象不变。
修饰类:*如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承*。因此一个类不能同时声明为abstract final或者interface final的。
修饰方法 :将方法声明为final，可以保证它们在使用中不被改变。被声明为final的方法也同样只能使用，不能重载。但是子类可以继承父类的final方法。
修饰变量 :表示属性值第一次初始化后不能被修改。final属性可以直接初始化或在构造函数中初始化.如果属性是直接初始化，则其值不能被其它函数(包括构造函数)修改。
修饰方法参数 :参数值不能被修改
修饰方法中的局部变量 : 局部变量被第一次初始化后不能被修改
注:任何在interface里声明的成员变量，默认为public static final。
使用final的意义:
第一，为方法“上锁”，防止任何继承类改变它的本来含义和实现。设计程序时，若希望一个方法的行为在继承期间保持不变，而且不可被覆盖或改写，就可以采取这种做法。
第二，提高程序执行的效率，将一个方法设成final后，编译器就可以把对那个方法的所有调用都置入“嵌入”调用里（内嵌机制）。
finally关键字:
在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块。 所以说finally块是一定会被执行的。
finally 语句块是在 try 或者 catch 中的 return 语句之前执行的。更加一般的说法是，finally 语句块应该是在控制转移语句之前执行，控制转移语句除了 return 外，还有 break 和 continue。 return 和 throw 把程序控制权转交给它们的调用者（invoker），而 break 和 continue 的控制权是在当前方法内转移。
finalize 方法名:
finalize（）方法是在垃圾收集器删除对象之前对这个对象调用的。

4.Java多线程线程池 - 线程池原理:
http://blog.csdn.net/mazhimazh/article/details/19243889

    public interface Executor {  
        void execute(Runnable command);  
    }  

Executors方便的创建线程池.
(1).newCachedThreadPool :该线程池比较适合没有固定大小并且比较快速就能完成的小任务，它将为每个任务创建一个线程。那这样子它与直接创建线程对象（new Thread()）有什么区别呢？看到它的第三个参数60L和第四个参数TimeUnit.SECONDS了吗？好处就在于60秒内能够重用已创建的线程。下面是Executors中的newCachedThreadPool()的源代码：　

    //基本的无界值（如 Integer.MAX_VALUE），则允许池适应任意数量的并发任务
    public static ExecutorService newCachedThreadPool() {  
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());  
        }  

(2).newFixedThreadPool:使用的Thread对象的数量是有限的,如果提交的任务数量大于限制的最大线程数，那么这些任务将排队，然后当有一个线程的任务结束之后，将会根据调度策略继续等待执行下一个任务。下面是Executors中的newFixedThreadPool()的源代码：　　

    public static ExecutorService newFixedThreadPool(int nThreads) {  
          return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());  
      }  

(3).newSingleThreadExecutor:就是线程数量为1的FixedThreadPool,如果提交了多个任务，那么这些任务将会排队，每个任务都会在下一个任务开始之前运行结束，所有的任务将会使用相同的线程。下面是Executors中的newSingleThreadExecutor()的源代码：　

    public static ExecutorService newSingleThreadExecutor() {  
            return new FinalizableDelegatedExecutorService  
                (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));  
        }  

(4).newScheduledThreadPool:创建一个固定长度的线程池，而且以延迟或定时的方式来执行任务。
ThreadPoolExecutor构造方法:

 public ThreadPoolExecutor(int corePoolSize,  //核心线程
                     int maximumPoolSize,  // 线程池维护的最大线程数量 
                     long keepAliveTime,  //线程池维护线程所允许的空闲时间
                     TimeUnit unit,  
                     BlockingQueue<Runnable> workQueue //// 阻塞队列  ) {  
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,  
        Executors.defaultThreadFactory(), defaultHandler);  
}  

ExecutorService:为了解决执行服务的生命周期问题，Executor扩展了EecutorService接口，添加了一些用于生命周期管理的方法。

ThreadPoolExecutor线程池实现类:

    private final BlockingQueue<Runnable> workQueue;              // 阻塞队列  
    private final ReentrantLock mainLock = new ReentrantLock();   // 互斥锁  
    private final HashSet<Worker> workers = new HashSet<Worker>();// 线程集合.一个Worker对应一个线程  
    private final Condition termination = mainLock.newCondition();// 终止条件  
    private int largestPoolSize;           // 线程池中线程数量曾经达到过的最大值。  
    private long completedTaskCount;       // 已完成任务数量  
    private volatile ThreadFactory threadFactory;     // ThreadFactory对象，用于创建线程。  
    private volatile RejectedExecutionHandler handler;// 拒绝策略的处理句柄  
    private volatile long keepAliveTime;   // 线程池维护线程所允许的空闲时间  
    private volatile boolean allowCoreThreadTimeOut;  
    private volatile int corePoolSize;     // 线程池维护线程的最小数量，哪怕是空闲的  
    private volatile int maximumPoolSize;  // 线程池维护的最大线程数量  

处理任务的优先级为：

• 核心线程corePoolSize > 任务队列workQueue > 最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
• 当池中的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求可处理就自行销毁。

workQueue :线程池所使用的缓冲队列，该缓冲队列的长度决定了能够缓冲的最大数量，缓冲队列有三种通用策略：
(1) 直接提交,工作队列的默认选项是 SynchronousQueue,它将任务直接提交给线程而不保持它们.
(2) 无界队列,使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列.
(3) 有界队列,当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折中：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量.

ThreadFactory:使用 ThreadFactory 创建新线程。如果没有另外说明，则在同一个 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 创建线程，并且这些线程具有相同的 NORM_PRIORITY 优先级和非守护进程状态。通过提供不同的 ThreadFactory，可以改变线程的名称、线程组、优先级、守护进程状态等等。如果从 newThread 返回 null 时 ThreadFactory 未能创建线程，则执行程序将继续运行，但不能执行任何任务。
在DefaultThreadFactory类中实现了ThreadFactory接口并对其中定义的方法进行了实现,如下:

    static class DefaultThreadFactory implements ThreadFactory {  
        private static final AtomicInteger poolNumber = new AtomicInteger(1);  
        private final ThreadGroup group;  
        private final AtomicInteger threadNumber = new AtomicInteger(1);  
        private final String namePrefix;  

        DefaultThreadFactory() {  
            SecurityManager s = System.getSecurityManager();  
            group = (s != null) ? s.getThreadGroup() :  Thread.currentThread().getThreadGroup();  
            namePrefix = "pool-" +  poolNumber.getAndIncrement() +  "-thread-";  
        }  
        // 为线程池创建新的任务执行线程  
        public Thread newThread(Runnable r) {  
            // 线程对应的任务是Runnable对象r  
            Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(), 0);  
            // 设为非守护线程  
            if (t.isDaemon())  
                t.setDaemon(false);  
            // 将优先级设为Thread.NORM_PRIORITY  
            if (t.getPriority() != Thread.NORM_PRIORITY)  
                t.setPriority(Thread.NORM_PRIORITY);  
            return t;  
        }  
    }  

RejectedExecutionHandler:
当Executor已经关闭（即执行了executorService.shutdown()方法后），并且Executor将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法execute()中提交的新任务将被拒绝.
　 在以上述情况下，execute 方法将调用其 RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略：

　　　　1) 在默认的 ThreadPoolExecutor.AbortPolicy 处理程序遭到拒绝将抛出运行时 RejectedExecutionException;
　　　　2) 在 ThreadPoolExecutor.CallerRunsPolicy 线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度

　　　　3) 在 ThreadPoolExecutor.DiscardPolicy 不能执行的任务将被删除;

　　　　4) 在 ThreadPoolExecutor.DiscardOldestPolicy 如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

线程池默认会采用的是defaultHandler策略。
具体案例见博客:(线程池源码的相关博客)
http://blog.csdn.net/mazhimazh/article/details/19243889
http://blog.csdn.net/mazhimazh/article/details/19283171
http://blog.csdn.net/mazhimazh/article/details/19291965
Callable接口代表一段可以调用并返回结果的代码;Future接口表示异步任务，是还没有完成的任务给出的未来结果。所以说Callable用于产生结果，Future用于获取结果。

以下内容来自http://www.trinea.cn/android/java-android-thread-pool/,再此简单记录.
new Thread的弊端:
a.每次new Thread新建对象性能差.
b.线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom.
c.缺乏更多功能，如定时执行、定期执行、线程中断.
Java提供的四种线程池的好处:
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
(1). newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
(2). newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。
(3) newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下
(4)、newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作，文件操作，应用批量安装，应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。