Android的一些异常汇总

最新推荐文章于 2024-08-20 18:21:23 发布
最新推荐文章于 2024-08-20 18:21:23 发布
阅读量784 收藏
点赞数
分类专栏： android

本片文章出自http://blog.csdn.net/andywuchuanlong，转载请说明出处，谢谢！

    之前遇到同行问的一些问题，能记住的我都将其写出来，供初学者参考。问题如下：

    1、四大组件全部结束销毁，为什么应用依然在后台运行？为什么不能真正的退出应用？

    2、Android中的service是在后台运行的服务，貌似线程也是在后台异步执行，为什么service不能被线程替代？

    3、使用View.inflate(context, resource, root)加载布局文件的时候，如果root为null，为什么布局文件的根节点设置的属性例如外边距、高度等都不起作用？

    4、网络请求的时候，我们都需要开启线程，那么是使用asyncTask还是使用Thread+Handler模式呢？

    5、为什么ScrollView中嵌套了ViewPager后，viewPager高度出现问题并且滑动失效？

             6、在项目中美工一般给我们切几套图，才能够适配Android碎片化的终端？

         7、Bitmap内存回收问题

         8、java语言是与平台无关的，项目中为了保证一些固定数据或者算法的安全性，我们一般会使用jni技术将其写在c里面，然而jni是与具体平台有关的，那么这中方式是不是违背了java语言的跨平台的特性？

        9、listview中的convertView复用过程是怎样的，它一定会被复用吗？

       10、Android中的ipc机制和aidl机制是什么关系？项目中什么情况下会使用到aidl？

       11、service、binder和aidl有什么联系？

       以上这些问题稍后我都会单独以文章的形式写出来，欢迎大家前来喷水交流。


本片文章出自http://blog.csdn.net/andywuchuanlong，转载请说明出处，谢谢！

    我答同行问序列目录http://blog.csdn.net/andywuchuanlong/article/details/44194043

    1、四大组件全部结束销毁，为什么应用依然在后台运行？为什么不能真正的退出应用？

    2、Android中的service是在后台运行的服务，貌似线程也是在后台异步执行，为什么service不能被线程替代？

    想要回答第一个问题就需要扯到Android内存管理机制。Android内存的管理有自己的一套机制，它有运行时和自己的虚拟机来管理自己的进程。java应用程序，程序代码运行结束，这个进程就会跟着销毁，而Android程序，就算所有的程序代码运行完毕，所在的进程也不见得会被销毁终止，也就是说Android有它自己管理进程生命周期的一套方式。换句话说Android系统可以自己控制进程的生命周期。当系统在遭遇内存瓶颈的时候，会通过杀死或者停止一些优先级比较低的进程，从而释放内存保证其他进程的运行，但是当系统内存足够的情况下，就算是一个空进程，系统也有可能不会对这个空进程下毒手，因为Android为了优化应用下一次的启动速度，这些比前台进程优先级低的会被缓存在内存中。

    上面提到了前台进程和空进程的概念，在Android中有五种进程的概念，优先级依次降低

    1、前台进程：一个用户当前工作所需要的，例如：

       当有一个Activity正与用户交互，onResume方法被调用，广播在执行onReceive方法，service在执行onCreate等方法，这个应用所在进程就可以视为前台进程，也称为活动进程。

    2、可视进程

            没有任何前台组件的进程，但是却是用户可以看到的，比如说Activity的onPause方法被调用，此时界面上呈现的是一个对话框

    3、服务进程

      用startService()启动的服务，但是不满足前面两类

    4、后台进程

      一个保存着当前用户不可视的进程，Activity的onStop被调用

    5、空进程

是一个没有保持活跃的应用程序组件的进程。保持这个进

程可用的唯一原因是作为一个

cache

以提高下次启动组件的速度

是一个没有保持活跃的应用程序组件的进程。保持这个进

程可用的唯一原因是作为一个

cache

以提高下次启动组件的速度

是一个没有保持活跃的应用程序组件的进程。保持这个进

程可用的唯一原因是作为一个

cache

以提高下次启动组件的速度

       不符合以上的条件的进程，通常来说空进程的存在是为了缓存在内存中以保证下一次的启动速度。

    第二个问题涉及到的就是上面所述的进程问题

    应用中的线程是由应用进程派生出来的，当这个进程从可视进程变为后台进程的时候，系统可能由于内存的压力会将其销毁，那么这些线程也会跟着销毁。然后service所在的进程会被作为一个服务进程运行在后台，从优先级可知，服务进程的优先级优先于后台进程，当内存不足时，后台进程会首先被销毁。

  3、使用View.inflate(context, resource, root)加载布局文件的时候，如果root为null，为什么布局文件的根节点设置的属性例如外边距、高度等都不起作用？

    分析这个问题的时候需要从远源码进行分析了,假设参数root为null，inflater.inflate(R.layout.item_list, parent,false);调用方式如下：

[java]  view plain copy
  1. <span style="color: rgb(51, 51, 51);">public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {</span><span style="color:#ff0000;">// attachToRoot  false</span><span style="color:#333333;">  
  2.         synchronized (mConstructorArgs) {  
  3.             final AttributeSet attrs = Xml.asAttributeSet(parser);  
  4.             Context lastContext = (Context)mConstructorArgs[0];  
  5.             mConstructorArgs[0] = mContext;  
  6.           </span><span style="color:#ff0000;">  View result = root;// 其实是resutl = null</span><span style="color:#333333;">  
  7.             try {  
  8.                 // Look for the root node.  
  9.                 int type;  
  10.                 while ((type = parser.next()) != XmlPullParser.START_TAG &&  
  11.                         type != XmlPullParser.END_DOCUMENT) {  
  12.                     // Empty  
  13.                 }  
  14.                 if (type != XmlPullParser.START_TAG) {  
  15.                     throw new InflateException(parser.getPositionDescription() + ": No start tag found!");  
  16.                 }  
  17.                 final String name = parser.getName();  
  18.                 if (TAG_MERGE.equals(name)) {  
  19.                     if (root == null || !attachToRoot) {  
  20.                         throw new InflateException("<merge /> can be used only with a valid "  
  21.                                 + "ViewGroup root and attachToRoot=true");  
  22.                     }  
  23.                     rInflate(parser, root, attrs, false);  
  24.                 } else {  
  25.                     // Temp is the root view that was found in the xml  
  26.                     View temp;  
  27.                     if (TAG_1995.equals(name)) {  
  28.                         temp = new BlinkLayout(mContext, attrs);  
  29.                     } else {  
  30.                         temp = createViewFromTag(root, name, attrs);  
  31.                     }  
  32.   
  33.                     ViewGroup.LayoutParams params = null;  
  34.   
  35.                     if (root != null) {  
  36.                         if (DEBUG) {  
  37.                             System.out.println("Creating params from root: " +  
  38.                                     root);  
  39.                         }  
  40.                         // Create layout params that match root, if supplied  
  41.                         params = root.generateLayoutParams(attrs);  
  42.                         if (!attachToRoot) {   </span><span style="color:#ff0000;">// true</span><span style="color:#333333;">  
  43.                             // Set the layout params for temp if we are not  
  44.                             // attaching. (If we are, we use addView, below)  
  45.                             temp.setLayoutParams(params);  
  46.                         }  
  47.                     }  
  48.   
  49.                     if (DEBUG) {  
  50.                         System.out.println("-----> start inflating children");  
  51.                     }  
  52.                     // Inflate all children under temp  
  53.                     rInflate(parser, temp, attrs, true);  
  54.                     if (DEBUG) {  
  55.                         System.out.println("-----> done inflating children");  
  56.                     }  
  57.   
  58.                     // We are supposed to attach all the views we found (int temp)  
  59.                     // to root. Do that now.  
  60.                     if (root != null && attachToRoot) {  
  61.                         root.addView(temp, params);  
  62.                     }  
  63.   
  64.                     // Decide whether to return the root that was passed in or the  
  65.                     // top view found in xml.  
  66.                     if (root == null || !attachToRoot) {  
  67.                         result = temp;  
  68.                     }  
  69.                 }  
  70.   
  71.             } catch (XmlPullParserException e) {  
  72.                 InflateException ex = new InflateException(e.getMessage());  
  73.                 ex.initCause(e);  
  74.                 throw ex;  
  75.             } catch (IOException e) {  
  76.                 InflateException ex = new InflateException(  
  77.                         parser.getPositionDescription()  
  78.                         + ": " + e.getMessage());  
  79.                 ex.initCause(e);  
  80.                 throw ex;  
  81.             } finally {  
  82.                 // Don't retain static reference on context.  
  83.                 mConstructorArgs[0] = lastContext;  
  84.                 mConstructorArgs[1] = null;  
  85.             }  
  86.   
  87.             return result;  
  88.         }  
  89.     }</span>  

代码比较长，我们重点关注下面的代码 

<span class="keyword" style="font-weight: bold;">if</span> (root != <span class="keyword" style="font-weight: bold;">null</span>) {
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span><span class="keyword" style="font-weight: bold;">if</span> (DEBUG) {
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span>    System.<span class="keyword" style="font-weight: bold;">out</span>.println(<span class="string" style="color: rgb(221, 17, 68);">"Creating params from root: "</span> +
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span><span class="indent">  </span>    root);
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span>}
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span><span class="comment" style="color: rgb(153, 153, 136); font-style: italic;">// Create layout params that match root, if supplied</span>
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span><span class="keyword" style="font-weight: bold;">params</span> = root.generateLayoutParams(attrs);
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span><span class="keyword" style="font-weight: bold;">if</span> (!attachToRoot) {
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span>    <span class="comment" style="color: rgb(153, 153, 136); font-style: italic;">// Set the layout params for temp if we are not</span>
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span>    <span class="comment" style="color: rgb(153, 153, 136); font-style: italic;">// attaching. (If we are, we use addView, below)</span>
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span>    temp.setLayoutParams(<span class="keyword" style="font-weight: bold;">params</span>);
<span class="indent">  </span><span class="indent">  </span><span class="indent">  </span>}
<span class="indent">  </span><span class="indent">  </span>    }
这些代码的意思就是，当我们传进来的root参数不是空的时候，并且attachToRoot是false的时候，也就是上面的TwoActivity的实现方式的时候，会给temp设置一个LayoutParams参数。那么这个temp又是干嘛的呢？ 
<pre name=<span class="string" style="color: rgb(221, 17, 68);">"code"</span> <span class="keyword" style="font-weight: bold;">class</span>=<span class="string" style="color: rgb(221, 17, 68);">"java"</span>><span class="comment" style="color: rgb(153, 153, 136); font-style: italic;">// We are supposed to attach all the views we found (int temp)</span>
<span class="indent">  </span><span class="comment" style="color: rgb(153, 153, 136); font-style: italic;">// to root. Do that now.</span>
<span class="indent">  </span><span class="keyword" style="font-weight: bold;">if</span> (root != <span class="keyword" style="font-weight: bold;">null</span> && attachToRoot) {
<span class="indent">  </span>    root.addView(temp, <span class="keyword" style="font-weight: bold;">params</span>);
<span class="indent">  </span>}

<span class="indent">  </span><span class="comment" style="color: rgb(153, 153, 136); font-style: italic;">// Decide whether to return the root that was passed in or the</span>
<span class="indent">  </span><span class="comment" style="color: rgb(153, 153, 136); font-style: italic;">// top view found in xml.</span>
<span class="indent">  </span><span class="keyword" style="font-weight: bold;">if</span> (root == <span class="keyword" style="font-weight: bold;">null</span> || !attachToRoot) {
<span class="indent">  </span>    result = temp;
<span class="indent">  </span>}
现在应该明白了吧，当我们传进来的root不是null，并且第三个参数是false的时候，这个temp就被加入到了root中，并且把root当作最终的返回值返回了。而当我们设置root为空的时候，没有设置  LayoutParams参数的temp对象，作为返回值返回了。

因此，我们可以得出下面的结论：

1.若我们采用 convertView = inflater.inflate(R.layout.item_list, null);方式填充视图，item布局中的根视图的layout_XX属性会被忽略掉，然后设置成默认的包裹内容方式

2.如果我们想保证item的视图中的参数不被改变，我们需要使用convertView = inflater.inflate(R.layout.item_list, parent,false);这种方式进行视图的填充

3.除了使用这种方式，我们还可以设置item布局的根视图为包裹内容，然后设置内部控件的高度等属性，这样就不会修改显示方式了。

简单总结一下：

  当root为null的时候，我们只是把一个xml文件实例化成view对象，返回的就是这个xml对应的view。当root不为空的时候，也就是parent存在，则将实例化后的view对象添加进parent中，然后返回

4、网络请求的时候，我们都需要开启线程，那么是使用asyncTask还是使用Thread+Handler模式呢？

    网络请求是每个app都需要进行的，很多人会使用asyncTask，也有人喜欢Thread+Handler，下面我按照我的想法讲解一下他们两者的区别。

    1、asyncTask

     asyncTask本质上也是一个线程池，2.3之前默认最多同时执行5个任务，是并行执行任务的。而3.0之后默认是串行执行，也就是说只有一个任务在执行，下面主要讲解下3.0之后的asyncTask。
     AsyncTask中维护者一个静态并发线程池，可以用来并行执行任务，尽管从3,0开始，AsyncTask默认是串行执行任务
但是我们仍然能构造出并行的AsyncTask。可能有人觉得奇怪了，明明维护者一个并发线程池，怎么说是串行执行的呢，主要还是AsyncTask维护了一个静态串行任务执行器其内部实现了串行控制，当任务开始执行的时候，这个task会被加入到任务队列中，然后从队列中循环的取出一个个的任务交给并发线程池去执行，这个任务执行器就是3.0之后默认的执行器，如果我们要改为并行执行把这个默认的执行器替换掉就可以了。任务执行完毕之后，会通过AsyncTask内部的一个handler发送消息到主线程，这里也就说明了为什么AsyncTask只能在ui线程中创建，因为AsyncTask内部维护了一个Handler，而消息时有Looper来循环的，子线程中默认是没有Looper的。  
      
[java]  view plain copy
  1. public abstract class AsyncTask<Params, Progress, Result> {  
  2.     private static final String LOG_TAG = "AsyncTask";  
  3.     //获取当前的cpu核心数    
  4.     private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();  
  5.   //线程池核心容量    
  6.     private static final int CORE_POOL_SIZE = CPU_COUNT + 1;  
  7.   //线程池最大容量    
  8.     private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;  
  9.     private static final int KEEP_ALIVE = 1;  
  10.   //ThreadFactory 线程工厂，通过工厂方法newThread来获取新线程    
  11.     private static final ThreadFactory sThreadFactory = new ThreadFactory() {  
  12.           //原子整数，可以在超高并发下正常工作   
  13.         private final AtomicInteger mCount = new AtomicInteger(1);  
  14.   
  15.         public Thread newThread(Runnable r) {  
  16.             return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());  
  17.         }  
  18.     };  
  19.     //静态阻塞式队列，用来存放待执行的任务，初始容量：128个  
  20.     private static final BlockingQueue<Runnable> sPoolWorkQueue =  
  21.             new LinkedBlockingQueue<Runnable>(128);  
  22.   
  23.     /** 
  24.      * 静态并发线程池，可以用来并行执行任务，尽管从3.0开始，AsyncTask默认是串行执行任务 
  25.      * 但是我们仍然能构造出并行的AsyncTask 
  26.      */    
  27.     public static final Executor THREAD_POOL_EXECUTOR  
  28.             = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,  
  29.                     TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);  
  30.   
  31.     /** 
  32.      * 静态串行任务执行器，其内部实现了串行控制， 
  33.      * 循环的取出一个个任务交给上述的并发线程池去执行 
  34.      */    
  35.     public static final Executor SERIAL_EXECUTOR = new SerialExecutor();  
  36.   //消息类型：发送结果    
  37.     private static final int MESSAGE_POST_RESULT = 0x1;  
  38.     //消息类型：更新进度    
  39.     private static final int MESSAGE_POST_PROGRESS = 0x2;  
  40.     /**静态Handler，用来发送上述两种通知，采用UI线程的Looper来处理消息 
  41.      * 这就是为什么AsyncTask必须在UI线程调用，因为子线程 
  42.      * 默认没有Looper无法创建下面的Handler，程序会直接Crash 
  43.      */    
  44.     private static final InternalHandler sHandler = new InternalHandler();  
  45.   //默认任务执行器，被赋值为串行任务执行器，就是它，AsyncTask变成串行的了    
  46.     private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;  
  47.     private final WorkerRunnable<Params, Result> mWorker;  
  48.     private final FutureTask<Result> mFuture;  
  49.   
  50.     private volatile Status mStatus = Status.PENDING;  
  51.       
  52.     private final AtomicBoolean mCancelled = new AtomicBoolean();  
  53.     private final AtomicBoolean mTaskInvoked = new AtomicBoolean();  
  54.     /**串行执行器的实现，我们要好好看看，它是怎么把并行转为串行的 
  55.      *目前我们需要知道，asyncTask.execute(Params ...)实际上会调用 
  56.      *SerialExecutor的execute方法，这一点后面再说明。也就是说：当你的asyncTask执行的时候， 
  57.      *首先你的task会被加入到任务队列，然后排队，一个个执行 
  58.      */    
  59.     private static class SerialExecutor implements Executor {  
  60.          //线性双向队列，用来存储所有的AsyncTask任务  
  61.         final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();  
  62.         //当前正在执行的AsyncTask任务   
  63.         Runnable mActive;  
  64.   
  65.         public synchronized void execute(final Runnable r) {  
  66.              //将新的AsyncTask任务加入到双向队列中   
  67.             mTasks.offer(new Runnable() {  
  68.                 public void run() {  
  69.                     try {  
  70.                          //执行AsyncTask任务    
  71.                         r.run();  
  72.                     } finally {  
  73.                         //当前AsyncTask任务执行完毕后，进行下一轮执行，如果还有未执行任务的话    
  74.                         //这一点很明显体现了AsyncTask是串行执行任务的，总是一个任务执行完毕才会执行下一个任务    
  75.                         scheduleNext();  
  76.                     }  
  77.                 }  
  78.             });  
  79.             if (mActive == null) {  
  80.                 //如果当前没有任务在执行，直接进入执行逻辑    
  81.                 scheduleNext();  
  82.             }  
  83.         }  
  84.   
  85.         protected synchronized void scheduleNext() {  
  86.             if ((mActive = mTasks.poll()) != null) {  
  87.                  //从任务队列中取出队列头部的任务，如果有就交给并发线程池去执行    
  88.                 THREAD_POOL_EXECUTOR.execute(mActive);  
  89.             }  
  90.         }  
  91.     }  
  92.   
  93.     /** 
  94.      * Indicates the current status of the task. Each status will be set only once 
  95.      * during the lifetime of a task. 
  96.      */  
  97.     /** 
  98.      * 任务的三种状态 
  99.      */    
  100.     public enum Status {  
  101.         /** 任务等待执行 
  102.          * Indicates that the task has not been executed yet. 
  103.          */  
  104.         PENDING,  
  105.         /**任务正在执行 
  106.          * Indicates that the task is running. 
  107.          */  
  108.         RUNNING,  
  109.         /**任务已经执行结束 
  110.          * Indicates that {@link AsyncTask#onPostExecute} has finished. 
  111.          */  
  112.         FINISHED,  
  113.     }  
  114.   
  115.     /** @hide Used to force static handler to be created.  
  116.      * 隐藏API：在UI线程中调用，用来初始化Handler  
  117.      * */  
  118.     public static void init() {  
  119. //        sHandler.getLooper();  
  120.     }  
  121.   
  122.     /** @hide  为AsyncTask设置默认执行器*/  
  123.     public static void setDefaultExecutor(Executor exec) {  
  124.         sDefaultExecutor = exec;  
  125.     }  
  126.   
  127.     /** 
  128.      * Creates a new asynchronous task. This constructor must be invoked on the UI thread. 
  129.      */  
  130.     public AsyncTask() {  
  131.         mWorker = new WorkerRunnable<Params, Result>() {  
  132.             public Result call() throws Exception {  
  133.                 mTaskInvoked.set(true);  
  134.   
  135.                 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
  136.                 //noinspection unchecked  
  137.                 return postResult(doInBackground(mParams));  
  138.             }  
  139.         };  
  140.   
  141.         mFuture = new FutureTask<Result>(mWorker) {  
  142.             @Override  
  143.             protected void done() {  
  144.                 try {  
  145.                     postResultIfNotInvoked(get());  
  146.                 } catch (InterruptedException e) {  
  147.                     android.util.Log.w(LOG_TAG, e);  
  148.                 } catch (ExecutionException e) {  
  149.                     throw new RuntimeException("An error occured while executing doInBackground()",  
  150.                             e.getCause());  
  151.                 } catch (CancellationException e) {  
  152.                     postResultIfNotInvoked(null);  
  153.                 }  
  154.             }  
  155.         };  
  156.     }  
  157.   
  158.     private void postResultIfNotInvoked(Result result) {  
  159.         final boolean wasTaskInvoked = mTaskInvoked.get();  
  160.         if (!wasTaskInvoked) {  
  161.             postResult(result);  
  162.         }  
  163.     }  
  164.   
  165.     private Result postResult(Result result) {  
  166.         @SuppressWarnings("unchecked")  
  167.         Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
  168.                 new AsyncTaskResult<Result>(this, result));  
  169.         message.sendToTarget();  
  170.         return result;  
  171.     }  
  172.   
  173.     /** 
  174.      * Returns the current status of this task. 
  175.      * 
  176.      * @return The current status. 
  177.      */  
  178.     public final Status getStatus() {  
  179.         return mStatus;  
  180.     }  
  181.   
  182.     /** 
  183.      * Override this method to perform a computation on a background thread. The 
  184.      * specified parameters are the parameters passed to {@link #execute} 
  185.      * by the caller of this task. 
  186.      * 
  187.      * This method can call {@link #publishProgress} to publish updates 
  188.      * on the UI thread. 
  189.      * 
  190.      * @param params The parameters of the task. 
  191.      * 
  192.      * @return A result, defined by the subclass of this task. 
  193.      * 
  194.      * @see #onPreExecute() 
  195.      * @see #onPostExecute 
  196.      * @see #publishProgress 
  197.      */  
  198.     protected abstract Result doInBackground(Params... params);  
  199.   
  200.     /** 
  201.      * Runs on the UI thread before {@link #doInBackground}. 
  202.      * 
  203.      * @see #onPostExecute 
  204.      * @see #doInBackground 
  205.      */  
  206.     protected void onPreExecute() {  
  207.     }  
  208.   
  209.     /** 
  210.      * <p>Runs on the UI thread after {@link #doInBackground}. The 
  211.      * specified result is the value returned by {@link #doInBackground}.</p> 
  212.      *  
  213.      * <p>This method won't be invoked if the task was cancelled.</p> 
  214.      * 
  215.      * @param result The result of the operation computed by {@link #doInBackground}. 
  216.      * 
  217.      * @see #onPreExecute 
  218.      * @see #doInBackground 
  219.      * @see #onCancelled(Object)  
  220.      */  
  221.     @SuppressWarnings({"UnusedDeclaration"})  
  222.     protected void onPostExecute(Result result) {  
  223.     }  
  224.   
  225.     /** 
  226.      * Runs on the UI thread after {@link #publishProgress} is invoked. 
  227.      * The specified values are the values passed to {@link #publishProgress}. 
  228.      * 
  229.      * @param values The values indicating progress. 
  230.      * 
  231.      * @see #publishProgress 
  232.      * @see #doInBackground 
  233.      */  
  234.     @SuppressWarnings({"UnusedDeclaration"})  
  235.     protected void onProgressUpdate(Progress... values) {  
  236.     }  
  237.   
  238.     /** 
  239.      * <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and 
  240.      * {@link #doInBackground(Object[])} has finished.</p> 
  241.      *  
  242.      * <p>The default implementation simply invokes {@link #onCancelled()} and 
  243.      * ignores the result. If you write your own implementation, do not call 
  244.      * <code>super.onCancelled(result)</code>.</p> 
  245.      * 
  246.      * @param result The result, if any, computed in 
  247.      *               {@link #doInBackground(Object[])}, can be null 
  248.      *  
  249.      * @see #cancel(boolean) 
  250.      * @see #isCancelled() 
  251.      */  
  252.     @SuppressWarnings({"UnusedParameters"})  
  253.     protected void onCancelled(Result result) {  
  254.         onCancelled();  
  255.     }      
  256.       
  257.     /** 
  258.      * <p>Applications should preferably override {@link #onCancelled(Object)}. 
  259.      * This method is invoked by the default implementation of 
  260.      * {@link #onCancelled(Object)}.</p> 
  261.      *  
  262.      * <p>Runs on the UI thread after {@link #cancel(boolean)} is invoked and 
  263.      * {@link #doInBackground(Object[])} has finished.</p> 
  264.      * 
  265.      * @see #onCancelled(Object)  
  266.      * @see #cancel(boolean) 
  267.      * @see #isCancelled() 
  268.      */  
  269.     protected void onCancelled() {  
  270.     }  
  271.   
  272.     /** 
  273.      * Returns <tt>true</tt> if this task was cancelled before it completed 
  274.      * normally. If you are calling {@link #cancel(boolean)} on the task, 
  275.      * the value returned by this method should be checked periodically from 
  276.      * {@link #doInBackground(Object[])} to end the task as soon as possible. 
  277.      * 
  278.      * @return <tt>true</tt> if task was cancelled before it completed 
  279.      * 
  280.      * @see #cancel(boolean) 
  281.      */  
  282.     public final boolean isCancelled() {  
  283.         return mCancelled.get();  
  284.     }  
  285.   
  286.     /** 
  287.      * <p>Attempts to cancel execution of this task.  This attempt will 
  288.      * fail if the task has already completed, already been cancelled, 
  289.      * or could not be cancelled for some other reason. If successful, 
  290.      * and this task has not started when <tt>cancel</tt> is called, 
  291.      * this task should never run. If the task has already started, 
  292.      * then the <tt>mayInterruptIfRunning</tt> parameter determines 
  293.      * whether the thread executing this task should be interrupted in 
  294.      * an attempt to stop the task.</p> 
  295.      *  
  296.      * <p>Calling this method will result in {@link #onCancelled(Object)} being 
  297.      * invoked on the UI thread after {@link #doInBackground(Object[])} 
  298.      * returns. Calling this method guarantees that {@link #onPostExecute(Object)} 
  299.      * is never invoked. After invoking this method, you should check the 
  300.      * value returned by {@link #isCancelled()} periodically from 
  301.      * {@link #doInBackground(Object[])} to finish the task as early as 
  302.      * possible.</p> 
  303.      * 
  304.      * @param mayInterruptIfRunning <tt>true</tt> if the thread executing this 
  305.      *        task should be interrupted; otherwise, in-progress tasks are allowed 
  306.      *        to complete. 
  307.      * 
  308.      * @return <tt>false</tt> if the task could not be cancelled, 
  309.      *         typically because it has already completed normally; 
  310.      *         <tt>true</tt> otherwise 
  311.      * 
  312.      * @see #isCancelled() 
  313.      * @see #onCancelled(Object) 
  314.      */  
  315.     public final boolean cancel(boolean mayInterruptIfRunning) {  
  316.         mCancelled.set(true);  
  317.         return mFuture.cancel(mayInterruptIfRunning);  
  318.     }  
  319.   
  320.     /** 
  321.      * Waits if necessary for the computation to complete, and then 
  322.      * retrieves its result. 
  323.      * 
  324.      * @return The computed result. 
  325.      * 
  326.      * @throws CancellationException If the computation was cancelled. 
  327.      * @throws ExecutionException If the computation threw an exception. 
  328.      * @throws InterruptedException If the current thread was interrupted 
  329.      *         while waiting. 
  330.      */  
  331.     public final Result get() throws InterruptedException, ExecutionException {  
  332.         return mFuture.get();  
  333.     }  
  334.   
  335.     /** 
  336.      * Waits if necessary for at most the given time for the computation 
  337.      * to complete, and then retrieves its result. 
  338.      * 
  339.      * @param timeout Time to wait before cancelling the operation. 
  340.      * @param unit The time unit for the timeout. 
  341.      * 
  342.      * @return The computed result. 
  343.      * 
  344.      * @throws CancellationException If the computation was cancelled. 
  345.      * @throws ExecutionException If the computation threw an exception. 
  346.      * @throws InterruptedException If the current thread was interrupted 
  347.      *         while waiting. 
  348.      * @throws TimeoutException If the wait timed out. 
  349.      */  
  350.     public final Result get(long timeout, TimeUnit unit) throws InterruptedException,  
  351.             ExecutionException, TimeoutException {  
  352.         return mFuture.get(timeout, unit);  
  353.     }  
  354.   
  355.     /** 
  356.      * Executes the task with the specified parameters. The task returns 
  357.      * itself (this) so that the caller can keep a reference to it. 
  358.      *  
  359.      * <p>Note: this function schedules the task on a queue for a single background 
  360.      * thread or pool of threads depending on the platform version.  When first 
  361.      * introduced, AsyncTasks were executed serially on a single background thread. 
  362.      * Starting with {@link android.os.Build.VERSION_CODES#DONUT}, this was changed 
  363.      * to a pool of threads allowing multiple tasks to operate in parallel. Starting 
  364.      * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, tasks are back to being 
  365.      * executed on a single thread to avoid common application errors caused 
  366.      * by parallel execution.  If you truly want parallel execution, you can use 
  367.      * the {@link #executeOnExecutor} version of this method 
  368.      * with {@link #THREAD_POOL_EXECUTOR}; however, see commentary there for warnings 
  369.      * on its use. 
  370.      * 
  371.      * <p>This method must be invoked on the UI thread. 
  372.      * 
  373.      * @param params The parameters of the task. 
  374.      * 
  375.      * @return This instance of AsyncTask. 
  376.      * 
  377.      * @throws IllegalStateException If {@link #getStatus()} returns either 
  378.      *         {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}. 
  379.      * 
  380.      * @see #executeOnExecutor(java.util.concurrent.Executor, Object[]) 
  381.      * @see #execute(Runnable) 
  382.      */ /** 
  383.      * 这个方法如何执行和系统版本有关，在AsyncTask的使用规则里已经说明，如果你真的想使用并行AsyncTask， 
  384.      * 也是可以的，只要稍作修改 
  385.      * 必须在UI线程调用此方法 
  386.      */    
  387.     public final AsyncTask<Params, Progress, Result> execute(Params... params) {  
  388.           //串行执行    
  389.         return executeOnExecutor(sDefaultExecutor, params);  
  390.         //如果我们想并行执行，这样改就行了，当然这个方法我们没法改    
  391.         //return executeOnExecutor(THREAD_POOL_EXECUTOR, params);   
  392.     }  
  393.   
  394.     /** 
  395.      * Executes the task with the specified parameters. The task returns 
  396.      * itself (this) so that the caller can keep a reference to it. 
  397.      *  
  398.      * <p>This method is typically used with {@link #THREAD_POOL_EXECUTOR} to 
  399.      * allow multiple tasks to run in parallel on a pool of threads managed by 
  400.      * AsyncTask, however you can also use your own {@link Executor} for custom 
  401.      * behavior. 
  402.      *  
  403.      * <p><em>Warning:</em> Allowing multiple tasks to run in parallel from 
  404.      * a thread pool is generally <em>not</em> what one wants, because the order 
  405.      * of their operation is not defined.  For example, if these tasks are used 
  406.      * to modify any state in common (such as writing a file due to a button click), 
  407.      * there are no guarantees on the order of the modifications. 
  408.      * Without careful work it is possible in rare cases for the newer version 
  409.      * of the data to be over-written by an older one, leading to obscure data 
  410.      * loss and stability issues.  Such changes are best 
  411.      * executed in serial; to guarantee such work is serialized regardless of 
  412.      * platform version you can use this function with {@link #SERIAL_EXECUTOR}. 
  413.      * 
  414.      * <p>This method must be invoked on the UI thread. 
  415.      * 
  416.      * @param exec The executor to use.  {@link #THREAD_POOL_EXECUTOR} is available as a 
  417.      *              convenient process-wide thread pool for tasks that are loosely coupled. 
  418.      * @param params The parameters of the task. 
  419.      * 
  420.      * @return This instance of AsyncTask. 
  421.      * 
  422.      * @throws IllegalStateException If {@link #getStatus()} returns either 
  423.      *         {@link AsyncTask.Status#RUNNING} or {@link AsyncTask.Status#FINISHED}. 
  424.      * 
  425.      * @see #execute(Object[]) 
  426.      */  
  427.     /** 
  428.      * 通过这个方法我们可以自定义AsyncTask的执行方式，串行or并行，甚至可以采用自己的Executor 
  429.      * 为了实现并行，我们可以在外部这么用AsyncTask： 
  430.      * asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, Params... params); 
  431.      * 必须在UI线程调用此方法 
  432.      */    
  433.     public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,  
  434.             Params... params) {  
  435.         if (mStatus != Status.PENDING) {  
  436.             switch (mStatus) {  
  437.                 case RUNNING:  
  438.                     throw new IllegalStateException("Cannot execute task:"  
  439.                             + " the task is already running.");  
  440.                 case FINISHED:  
  441.                     throw new IllegalStateException("Cannot execute task:"  
  442.                             + " the task has already been executed "  
  443.                             + "(a task can be executed only once)");  
  444.             }  
  445.         }  
  446.   
  447.         mStatus = Status.RUNNING;  
  448.   
  449.         onPreExecute();  
  450.   
  451.         mWorker.mParams = params;  
  452.         exec.execute(mFuture);  
  453.   
  454.         return this;  
  455.     }  
  456.   
  457.     /** 
  458.      * Convenience version of {@link #execute(Object...)} for use with 
  459.      * a simple Runnable object. See {@link #execute(Object[])} for more 
  460.      * information on the order of execution. 
  461.      * 
  462.      * @see #execute(Object[]) 
  463.      * @see #executeOnExecutor(java.util.concurrent.Executor, Object[]) 
  464.      *//** 
  465.      * 这是AsyncTask提供的一个静态方法，方便我们直接执行一个runnable 
  466.      */    
  467.     public static void execute(Runnable runnable) {  
  468.         sDefaultExecutor.execute(runnable);  
  469.     }  
  470.   
  471.     /** 
  472.      * This method can be invoked from {@link #doInBackground} to 
  473.      * publish updates on the UI thread while the background computation is 
  474.      * still running. Each call to this method will trigger the execution of 
  475.      * {@link #onProgressUpdate} on the UI thread. 
  476.      * 
  477.      * {@link #onProgressUpdate} will note be called if the task has been 
  478.      * canceled. 
  479.      * 
  480.      * @param values The progress values to update the UI with. 
  481.      * 
  482.      * @see #onProgressUpdate 
  483.      * @see #doInBackground 
  484.      */  
  485.     protected final void publishProgress(Progress... values) {  
  486.         if (!isCancelled()) {  
  487.             sHandler.obtainMessage(MESSAGE_POST_PROGRESS,  
  488.                     new AsyncTaskResult<Progress>(this, values)).sendToTarget();  
  489.         }  
  490.     }  
  491.   
  492.     private void finish(Result result) {  
  493.         if (isCancelled()) {  
  494.             onCancelled(result);  
  495.         } else {  
  496.             onPostExecute(result);  
  497.         }  
  498.         mStatus = Status.FINISHED;  
  499.     }  
  500.   //AsyncTask内部Handler，用来发送后台计算进度更新消息和计算完成消息    
  501.     private static class InternalHandler extends Handler {  
  502.         @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})  
  503.         @Override  
  504.         public void handleMessage(Message msg) {  
  505.             AsyncTaskResult result = (AsyncTaskResult) msg.obj;  
  506.             switch (msg.what) {  
  507.                 case MESSAGE_POST_RESULT:  
  508.                     // There is only one result  
  509.                     result.mTask.finish(result.mData[0]);  
  510.                     break;  
  511.                 case MESSAGE_POST_PROGRESS:  
  512.                     result.mTask.onProgressUpdate(result.mData);  
  513.                     break;  
  514.             }  
  515.         }  
  516.     }  
  517.   
  518.     private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {  
  519.         Params[] mParams;  
  520.     }  
  521.   
  522.     @SuppressWarnings({"RawUseOfParameterizedType"})  
  523.     private static class AsyncTaskResult<Data> {  
  524.         final AsyncTask mTask;  
  525.         final Data[] mData;  
  526.   
  527.         AsyncTaskResult(AsyncTask task, Data... data) {  
  528.             mTask = task;  
  529.             mData = data;  
  530.         }  
  531.     }  
  532. }  
      2、Thread+Handler模式
      每个需要请求服务器的地方都创建一个线程，等到线程执行完毕就通过handler发送消息到主线程。这样的线程运行是不受控制的。

     总结一下：
     AsyncTask是封装好的线程池，比起Thread+Handler的方式，AsyncTask在操作UI线程上更方便，因为onPreExecute()、onPostExecute()及更新UI方法onProgressUpdate()均运行在主线程中，这样就不用Handler发消息处理了。
     AsyncTask真正的缺点来自于3.0之前全局线程池只有5个工作线程，也就是说，一个APP如果运用AsyncTask技术来执行线程，那么同一时间最多只能有5个线程同时运行，其他线程将被阻塞，但是在3.0之后可以自定义执行器，多少个线程同时运行不受到限制。不运用AsyncTask执行的线程，也就是自己new出来的线程不受此限制。
     所以在3.0之前AsyncTask不要用于多线程取网络数据，因为很可能这样会产生阻塞，从而降低效率。 3.0之后我建议最好是使用 AsyncTask。

5、为什么ScrollView中嵌套了ViewPager后，viewPager高度出现问题并且滑动失效？

   ScrollView是可以滑动的，而viewPager也是可以进行滑动的，虽然说两者嵌套不违反view的嵌套原则，但是Android系统里面可以滑动的组件里面是不可以嵌套可滑动的组件的，因为这样组件不好测量。

   下面讲述一下解决方案：

解决方法只需要在接近水平滚动时ScrollView不处理事件而交由其子View(即这里的ViewPager)处理即可，重写ScrollView的onInterceptTouchEvent函数

[java]  view plain copy
  1. <span style="font-family:Courier New;font-size:14px;">public class VerticalScrollView extends ScrollView {  
  2.     private GestureDetector mGestureDetector;  
  3.     public VerticalScrollView(Context context, AttributeSet attrs){  
  4.         super(context, attrs);  
  5.         mGestureDetector = new GestureDetector(context, new ScrollDetector());  
  6.     }  
  7.     @Override  
  8.     public boolean onInterceptTouchEvent(MotionEvent ev) {  
  9.         return super.onInterceptTouchEvent(ev) && mGestureDetector.onTouchEvent(ev);  
  10.     }  
  11.     class ScrollDetector extends SimpleOnGestureListener {  
  12.         @Override  
  13.         public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {  
  14.             return (Math.abs(distanceY) > Math.abs(distanceX));  
  15.         }  
  16.     }  
  17. }</span>  
             对于高度的问题，可以使用下列解决方案：

                   1、设置ScrollView的fillViewPort为true
                  2、设置ViewPager的layout_height为一个固定高度，比如：100dip

 6、在项目中美工一般给我们切几套图，才能够适配Android碎片化的终端？

      这个问题是属于Android终端屏幕适配的问题。读者可以访问我下列的文章《Android屏幕适配》一文，便大概可以回答这个问题了。

      我再此处只想讲述下我在项目中的适配是如何做的。在项目中我一般只会切一套图，这套图放在hdpi目录下面，这样有些地方可能还适配不了，那就需要切一些单独的图，但是整体来说工作量也只有一套图的工作量。

      读者可能奇怪了，为什么你会切出来的娿图片放在hdpi目录下面，而不放在其他的mdpi、xdpi目录下面呢？我觉得有两点原因，

              第一点：如果放在mdpi目录下，那么图片到了高分辨率的终端上面就会出现模糊的情况，用户体验太差，如果放在xdpi以上的目录，那么这些图片放在mdpi的目录下时候，有可能会出现内存崩溃的现象。

              第二点：现在市场上屏幕最多的分辨率是480*800，所以对这个适配就好，其他的再修复适配。那么480*800和hdpi有什么关系呢？我们可以使用数学来算一下。480*800代表的屏幕是4.0英寸的，我们可以算一下这种情况下的终端密度是多少，((480^2 + 800^2)开根号 )/4英寸=233 ，233接近240。而240是hdpi所代表的屏幕密度。所以适配480*800的屏幕放在hdpi目录下最合适不过了。

       那么480*800上的图该如何切呢？这就要看一下我上次的文章《Android屏幕适配》了 。在这里我也再讲述一下我的切图方案。如果一张20*20或者30*30的图标在480*800上面适配。那么在xdpi上面该切多大的呢?xdpi是与720*1280分辨率对应的，这两种分辨率是2:3的关系，480*800上的20*20可以适配，那么在720*1280切上30*30的图标就合适了。可是上面不是讲了我只切一套图吗，怎么这两种分辨下同一图标会有两个不同大小呢。别急啊，既然他们是2:3的关系，那么不可以去他们的公倍数吗2:3不就是6的倍数了，所以如果20*20的图标在480*800上适合，那么切一张60*60的图标就可以适配这两种分辨率的屏幕了。

       以上是不可能解决所有问题的，具体问题具体对待！


会飞牛牛
关注
专栏目录
Android一些小异常
笨鸟的专栏
02-22 400
往github中上传本地项目 adb logcat获取/过滤日志信息 13、AS修改Git密码：控制面板 --> 用户账户 --> 管理Window凭据 --> 普通凭据 有git内容 点击修改即可 12、关于R文件超过默认大小，编译提示R文件找不到的问题 https://www.jianshu.com/p/f1f2ee3b8ea3 11、TextView...
Android Timer使用的异常：Timer was canceled 处理方法
weixin_34186128的博客
05-28 347
1 异常日志：java.lang.IllegalStateException:Timerwascanceled2 所做操作：调用cancel()取消后不能再执行 schedule语句，否则提示出现以上异常。3 解决方案：正确的中止Timer方法：timer....
已解决：java.util.concurrent.CancellationException
最新发布
屿小夏.的知识博客
08-20 776
进行并发任务管理时。本文将详细分析这个异常的背景、原因、以及如何通过代码示例来避免该异常的发生。，确保并发程序的健壮性和可维护性。希望本文能帮助您理解并解决这一常见的并发编程问题。结果之前检查任务是否已被取消。是一种运行时异常，通常在尝试获取一个已取消的。在并发编程中，异常的处理尤为重要。是一个常见的异常，尤其是在使用。以下代码展示了一个容易引发。通过这些措施，可以有效避免。
Android Studio 运行时出现 finished with non-zero exit value 2 错误分析
银灵子
03-29 3万+
错误日志： com.android.ide.common.process.ProcessException: org.gradle.process.internal.ExecException: Process 'command '/Library/Java/JavaVirtualMachines/jdk1.7.0_71.jdk/Contents/Home/bin/java'' finished
SWING WORKER EXAMPLE
DViewer的专栏
07-18 494
Java provides a neat way to carry out long lasting jobs without have to worry about the complexity of threads or lack of responsiveness in an application (by application we mean Swing applications). I
kotlin异常处理之----取消异常CancellationException与其他异常的区别，协程异常处理顺序
GGGL的专栏
10-06 1307
CancellationException异常是协程专门用来取消协程而使用，与其他异常在处理上是有区别的 协程内部使用CancellationException来进行取消操作，这个异常会被忽略掉。 当子协程取消后，不会取消父协程。（如果是其他异常，父协程也完蛋喽！） 如果一个协程遇到CancellationException以外的异常，它将使用该异常来取消父协程。当父协程和子协程都结束后，异常才会被父协程处理。
android setvisibility空指针异常,Android遇到的一些问题汇总
weixin_35687240的博客
05-28 596
一.资源文件报空指针，转换异常，但是明明写的都是正确的，那么这个时候，需要考虑下下面这种情况？1.当我们的Android程序有多个module的情况下，如果在有模块引入别的模块的情况，主模块的资源文件会覆盖子模块所有的资源，导致子模块获取的资源是主模块的资源。2.这里的资源文件(layout,string,color,style等)但是不包含id，如果不同模块的id相同的话，这个是没有问题，除了包...
Android Studio出错异常汇总
whiteGu的博客
05-23 1273
初次使用Android Studio 异常汇总以及解决方案本人非专业Android开发；下面的内容只是我遇到然后解决的方案。error while loading state for instance 0x0 of device 'goldfish_pipe'resizing partition e2fsck failed with exit code 8Emulator: ERROR: resizing partition e2fsck failed with exit code 8 本人非专业Andro
Crashlytics Android 异常报告统计管理(详解)
08-30
本篇文章将详细介绍如何在Android平台上使用Crashlytics进行异常报告的统计管理。 首先，Crashlytics的核心优势在于其全面性和易用性。它确保不会遗漏任何应用崩溃信息，即使在iTunes Connect后台看不到的崩溃情况...
Android审查：:fire:Android复习资料汇总（每周持续更新〜）
02-02
- **Java编程语言**：Android应用主要由Java编写，理解其面向对象编程基础、异常处理、集合框架和多线程是必不可少的。 - **Android SDK**：掌握Android Software Development Kit的使用，包括Android Studio IDE...
android 线程 结束线程结束,Android 多线程之判断线程结束
weixin_30465509的博客
05-27 1240
Android 多线程之判断线程结束最近在做多线程断点线程的时候，遇到一个问题，因为需要在多线程下载完成时候，对文件进行处理，而处理肯定是在文件下载完成时候，而下载完成时候肯定是多线程都完成时候，所以怎么判断多线程完成呢？也是百度了很多文章，也都试了试。但是都发现不能解决自己的问题。没有解决问题的方案1.线程池 然后shutdown 然后判断是否terminate，如果terminate返回为tr...
已解决java.util.concurrent.CancellationException异常的正确解决方法，亲测有效！！！
小明的Java问道之路
02-02 2万+
已解决java.util.concurrent.CancellationException异常的正确解决方法，亲测有效！！！
xdebug Debug session was finished without being paused
SakuraLLj的专栏
09-26 6389
报错信息 Debug session was finished without being paused It may be caused by path mappings misconfiguration or not synchronized local and remote projects. To figure
Android多线程任务优化2：实现后台预读线程
lzc的专栏
09-23 1万+
转载请注明出处。博客地址：http://blog.csdn.net/mylzc 导语：从上一篇《多线程任务的优化1：探讨AsyncTask的缺陷》我们了解到，使用AsyncTask有导致应用FC的风险，而且AsyncTask并不能满足我们一些特定的需求。下面我们介绍一种通过模仿
Android之平时遇见的异常和错误总结（不断更新）
热门推荐
码莎拉蒂
10-01 9万+
安卓错误经验累积 1、当出现下面错误时候 08-21 03:43:16.679: E/AndroidRuntime(1087): java.lang.RuntimeException: Unable to start activity ComponentInfo{com.example.fragment/com.example.fragment.MainActivity}: andr
Android系统源码阅读（16）：Android 应用线程的消息循环模型
天天吃吃
12-04 887
Android系统源码阅读（16）：Android 应用线程的消息循环模型 读书不宜拖沓 0. 背景 Android应用的主线程为ActivityThread，在第（10）章已经讲过，它主要负责处理界面事件，所以开发者应该避免在主线程中处理耗时的任务。为了减轻主线程的负担，开发者应该启用多线程来处理耗时的任务。在Android中可以创建多种线程，有的线程可以有自己的消息循环，
协程中的取消和异常 | 取消操作详解
谷歌开发者
07-04 2425
在日常的开发中，我们都知道应该避免不必要的任务处理来节省设备的内存空间和电量的使用——这一原则在协程中同样适用。您需要控制好协程的生命周期，在不需要使用的时候将它取消，这也是结构化并发所...
2013经典Android面试题汇总：内存回收、异常处理与资源管理
2. **RuntimeException**异常：给出的多选题中，ArithmeticException（算术异常）、IllegalArgumentException（无效参数异常）、NullPointerException（空指针异常）和BufferUnderflowException（缓冲区下溢异常）都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值