Android Service、AsyncTask

最新推荐文章于 2021-05-26 20:13:25 发布

小白到大白

最新推荐文章于 2021-05-26 20:13:25 发布

阅读量459

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Android Service AsyncTask Java

本文链接：https://blog.youkuaiyun.com/qq_37270307/article/details/98473595

Android 同时被 3 个专栏收录

5 篇文章

订阅专栏

Service

1 篇文章

订阅专栏

AsyncTask

1 篇文章

订阅专栏

本文深入剖析Android中Service的工作原理，包括bindService与startService的区别，onCreate、onStartCommand等方法的运行时机及线程环境。同时，详细解读AsyncTask的内部实现，如串行与并行执行模式，以及其与线程池的交互。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Service原理

1、先看下面代码，在MainActivity中启动Service，在Service中打印生命周期Log和生命周期所处的线程

public class MainActivity extends AppCompatActivity {
 @Override
 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Intent intent = new Intent(this, MyService.class);
    startService(intent);
  }
}

public class MyService extends Service {
 private final String TAG = "MyService";
 @Override
 public void onCreate() {
 super.onCreate();
 Log.e(TAG, "onCreate Thread = " + Thread.currentThread());
 }
 @Override
 public IBinder onBind(Intent intent) {
 Log.e(TAG, "onBind Thread = " + Thread.currentThread());
 return new MyOnBind();
 }
 @Override
 public int onStartCommand(Intent intent, int flags, int startId) {
 Log.e(TAG, "onStartCommand Thread = " + Thread.currentThread());
 return super.onStartCommand(intent, flags, startId);
 }
 //若这里继承Aidl的Stub类，并且有其他进程绑定此Service
 //最好写个方法返回Service
 public class MyOnBind extends Binder {
   public MyService getService() {
     return MyService.this;
      }
  }
}

打印Log如下，可以看出onCreate和onStartCommand运行在主线程

onCreate Thread =Thread[main,5,main]
onStartCommand Thread = Thread[main,5,main]

2、修改MainActivity的代码如下，Service的代码不变，运行打印Log

mConnection = new MyConnection();
Intent intent = new Intent(this, MyService.class);
bindService(intent, mConnection, BIND_AUTO_CREATE);
private class MyConnection implements ServiceConnection {
 @Override
 public void onServiceConnected(ComponentName name, IBinder service) {
 Log.e(TAG, "onServiceConnected Thread = " + 
       Thread.currentThread());
 }
 @Override
 public void onServiceDisconnected(ComponentName name) {
     }
  }

Log打印如下：

onCreate Thread =Thread[main,5,main]
onBind Thread = Thread[main,5,main]
onServiceConnected Thread = Thread[main,5,main]

注意：

一、bindService不会运行onStartCommand方法，并且onServiceConnected和onServiceDisconnected方法都是运行在主线程中

二、如果多次运行bindService方法和startService，onStartCommand会运行多次，onCreate和onBind通常只会运行一次，当然stopService()也可以调用多次，但Service中的onDestroy()也只会调用一次，读者可以自行去验证。

三、那么什么情况下Service的onCreate和onBind会运行多次呢？如果这个服务意外销毁，并且在onStartCommand方法中返回 START_REDELIVER_INTENT，则会运行onCreate()方法；如果是用Aidl连接Service,则onBind会运行多次。

3、onStartCommand返回的数值代表的作用

一、START_STICKY_COMPATIBILITY; 调用了onCreate 方法，没有调用 onStartCommand

二、START_STICKY; 再次调用 onCreate、onStartCommand，并且 startId = 2, 但是 intent = null

三、START_NOT_STICKY; 没有重启

四、START_REDELIVER_INTENT; 再次调用 onCreate、onStartCommand，并且 startId = 1, 但是 intent 不为 null 说明该 int 可以保留上次的 startId 与 intent

AsyncTask原理

AsyncTask相信大家都不陌生，可以用来异步加载数据

1、AsyncTask有四个方法 : onPreExecute(); onProgressUpdate(); doInBackground(); onPostExecute(); 这四个方法怎么用我就不讲了，注意的是doInBackground是运行在子线程里，其他三个方法是运行在主线程里，内部通过handle将doInBackground的数据传递给onPostExecute();

2、AsyncTask内部其实有用到线程池（这里具体不讲线程池），在Android3.0以前，AsyncTask是并联运行，而Android3.0以后是串行运行。什么意思呢？

并联运行 : 就是运行多个AsycnTask.execute()，会同时进行异步加载数据

串行运行：运行多个AsycnTask.execute()，不会同时进行加载数据，将一个个按顺序执行，执行完第一个才会执行第二个，以此类推执行完全部。

如下代码：在MianActivity中运行多个execute()方法，在AsyncTask中的代码如下，休眠三秒。


public class MainActivity extends AppCompatActivity {
   private final String TAG = "MainActivity";
    
    @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

       new MyAsyncTask().execute();
       new MyAsyncTask().execute();
       new MyAsyncTask().execute();
       new MyAsyncTask().execute();

    }

public class MyAsyncTask extends AsyncTask {

  @Override
  protected void onPreExecute() {
      super.onPreExecute();
  }

  @Override
  protected void onProgressUpdate(Object[] values) {
      super.onProgressUpdate(values);
  }

  @Override
  protected Object doInBackground(Object[] objects) {
      try {
          Thread.sleep(3000);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      return null;
  }
    
    @Override
  protected void onPostExecute(Object o) {
      super.onPostExecute(o);
      Log.e("MyAsyncTask", "Time = " + System.currentTimeMillis());
  }
}

打印的Log如下；可以看到AsyncTask是串行运行的

3、接下来一起来看下AsyncTask的内部源码：

点击execute()方法进入源码，注意的是这里默认有个sDefaultExecutor,

在点击executeOnExecutor方法查看

@MainThread
 public final AsyncTask<Params, Progress, Result> execute(Params... params) {
  return executeOnExecutor(sDefaultExecutor, params);
 }

这里运行了onPreExecute方法，以及传进来sDefaultExecutor的execute方法。


......
if (mStatus != Status.PENDING) {
......
        onPreExecute();
        mWorker.mParams = params;
        exec.execute(mFuture);
......
}

回到之前，查看sDefaultExecutor，这里方便查看我调整了下源码位置，sDefaultExecutor其实就是SerialExecutor，SerialExecutor保证了串行运行，然后将任务交给THREAD_POOL_EXECUTOR线程池

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//负责将数据从线程回调到主线程
private static InternalHandler sHandler;

//静态，所以多次调用 new MyAsyncTask().execute();运行的是同一个
private static class SerialExecutor implements Executor {
   //mTasks是个线性双向队列，用来存储所有的AsyncTask任务
   final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
   Runnable mActive;
   
   public synchronized void execute(final Runnable r) {
         //将新的AsyncTask加入到双向队列中
       mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run(); //执行AsyncTask任务
                } finally {
            //当前AsyncTask执行完，进行下一轮执行。很明显AsyncTask
            //是串行执行的，总是一个任务执行完毕才会执行下一个任务
                    scheduleNext();
                }
            }
        });
          //如果当前没有任务执行，直接执行
          if (mActive == null) {
              scheduleNext();
          }
       }

     protected synchronized void scheduleNext() {
     //从任务队列中取出头部任务，交给并发线程池去执行
          if ((mActive = mTasks.poll()) != null) {
              THREAD_POOL_EXECUTOR.execute(mActive);
          }
       }
    }

//获取当前CPU核心数
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//线程池核心线程数
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
//线程池最大线程数
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
//空闲的线程存活时间
private static final int KEEP_ALIVE_SECONDS = 30;
//Thread工厂 通过工厂方法newThread来获取新线程
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);
        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };
//静态阻塞式队列，用来存放待执行的任务，初始容量：128个
private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

//并发线程池
public static final Executor THREAD_POOL_EXECUTOR;

    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }
    
//这个Handler负责将数据从线程中回调到主线程
private static Handler getMainHandler() {
     synchronized (AsyncTask.class) {
         if (sHandler == null) {
             sHandler = new InternalHandler(Looper.getMainLooper());
         }
         return sHandler;
     }
 }    

private static class InternalHandler extends Handler {
      public InternalHandler(Looper looper) {
          super(looper);
      }

      @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
      @Override
      public void handleMessage(Message msg) {
          AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
          switch (msg.what) {
              //将最后数据回调给onPostExecute
              case MESSAGE_POST_RESULT:
                  // There is only one result
                  result.mTask.finish(result.mData[0]);
                  break;
              case MESSAGE_POST_PROGRESS:
              //将加载中的数据回调给onProgressUpdate
                  result.mTask.onProgressUpdate(result.mData);
                  break;
          }
      }
  }

4、从以上分析可以看出AsyncTask是串行运行的，那么有没有方法并行运行呢？可以如下修改代码，其中MyAsyncTask代码没变

public class MainActivity extends AppCompatActivity {
    private final String TAG = "MainActivity";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
      //计算CPU核心数，不同的手机可能不一样
      int CPU_COUNT = Runtime.getRuntime().availableProcessors();
      Log.e(TAG, "CPU_COUNT = " + CPU_COUNT);

      new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
      new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
      new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
      new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
   }

Log打印如下：

最后总结：

1、 Service:

一、bindService不会运行onStartCommand方法，并且onServiceConnected和onServiceDisconnected方法都是运行在主线程中

四、注意onStartCommand中的返回值

2、 AsyncTask

一、AsyncTask现在版本默认是串行的，里面用到的是sDefaultExecutor，mTasks将任务保存，mActive将头部任务取出进行下次执行。

二、若想多次运行execute()方法，可以这样写


new MyAsyncTask().execute();
new MyAsyncTask().execute();
new MyAsyncTask().execute();

但不能这样写，这样会报错

MyAsyncTask myAsyncTask = new MyAsyncTask();
myAsyncTask.execute();
myAsyncTask.execute();
myAsyncTask.execute();

三、AsyncTask有四个方法 : onPreExecute(); onProgressUpdate(); doInBackground(); onPostExecute(); 这四个方法怎么用我就不讲了，注意的是doInBackground是运行在子线程里，其他三个方法是运行在主线程里，内部通过handle将doInBackground的数据传递给onPostExecute()方法，内部有用到线程池。

四、AsyncTask不是被设计为处理耗时操作的，耗时上限为几秒钟，如果要做长耗时操作，强烈建议你使用Executor，ThreadPoolExecutor以及FutureTask