Android线程

1、引言

在Android中,几乎完全采用了Java的线程机制,由于Android的特性,主线程只处理和界面相关的事情,子线程处理耗时操作。Android中扮演线程角色的有Thread、AsyncTask、IntentService和HandlerThread。对于AsyncTask来说,底层用到了线程池,对于IntentService和HandlerThread,底层用到了线程。

2、AsyncTask

AsyncTask是一个抽象的泛型类,它提供了Params、Progress和Result这三个泛型参数。

public abstract class AsyncTask 

其中Params表示参数类型,Progress表示后台任务的执行进度的类型,Result表示后台任务返回结果的类型。并且提供了五个核心的方法。

@MainThread
protected void onPreExecute() {
}

此方法有个@MainThread注解,表示在主线程执行,在异步任务执行之前,此方法会被调用,一般可以做一些准备工作。

@WorkerThread
protected abstract Result doInBackground(Params... params);

此方法有个@WorkerThread注解,表示在工作(子)线程执行,用于执行异步任务,params参数表示异步任务的输入参数,可调用publishProgress方法来更新任务进度,publishProgress会调用onProgressUpdate方法。并且此方法需要返回计算结果给onPostExecute方法。

@MainThread
protected void onPostExecute(Result result) {
}

在主线程中执行,在异步任务执行后,此方法会被调用,result是后台任务的返回值。

@MainThread
protected void onProgressUpdate(Progress... values) {
}

在主线程中执行,后台任务的执行进度发生变化时,此方法会被调用。

@MainThread
protected void onCancelled(Result result) {
    onCancelled();
}    

在主线程中执行,当异步任务被取消是,此方法会被调用,而onPostExecute则不会被调用。

class MyTask extends AsyncTask {

    @Override
    protected void onPreExecute() {
        Log.i(TAG, "onPreExecute() called");
        textView.setText("loading...");
    }

    @Override
    protected String doInBackground(String... strings) {
        Log.i(TAG, "doInBackground(Params... params) called");
        try {
            OkHttpClient client = new OkHttpClient.Builder().readTimeout(5, TimeUnit.SECONDS).build();
            Request request = new Request.Builder()
                    .url(strings[0])
                    .get()
                    .build();
            Call call = client.newCall(request);
            Response response = call.execute();
            if (response.code() == 200) {
                InputStream is = response.body().byteStream();
                long total = response.body().contentLength();
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int count = 0;
                int length = 0;
                while ((length = is.read(buf)) != -1) {
                    baos.write(buf, 0, length);
                    count += length;
                    //调用publishProgress公布进度,最后onProgressUpdate方法将被执行
                    publishProgress((int) (count * 1.0f / total * 100));
                    //为了演示进度,休眠500毫秒
                    Thread.sleep(500);
                }
                return new String(baos.toByteArray(), "utf8");
            }
        } catch (Exception e) {
            Log.e(TAG, e.getMessage());
        }
        return null;
    }

    //onProgressUpdate方法用于更新进度信息
    @Override
    protected void onProgressUpdate(Integer... progresses) {
        Log.i(TAG, "onProgressUpdate(Progress... progresses) called");
        progressBar.setProgress(progresses[0]);
        textView.setText("loading..." + progresses[0] + "%");
    }

    //onPostExecute方法用于在执行完后台任务后更新UI,显示结果
    @Override
    protected void onPostExecute(String result) {
        Log.i(TAG, "onPostExecute(Result result) called");
        textView.setText(result);

        execute.setEnabled(true);
        cancel.setEnabled(false);
    }

    //onCancelled方法用于在取消执行中的任务时更改UI
    @Override
    protected void onCancelled() {
        Log.i(TAG, "onCancelled() called");
        textView.setText("cancelled");
        progressBar.setProgress(0);

        execute.setEnabled(true);
        cancel.setEnabled(false);

    }
}

上面代码中,实现一个具体的AsyncTask类,主要模拟get请求,并且更新progress。
AsyncTask使用限制

  • 类必须在主线程中加载
  • 对象必须在主线程中创建
  • execute方法必须在UI线程调用
  • 不要在程序中直接调用onPreExecute、onPostExecute、doInBackground、onProgressUpdate方法
  • 一个AsyncTask对象只能执行一次,多次执行会报运行时异常。

3、HandlerThread

HandlerThread本质上是一个线程类,它继承了Thread,并且可以创建一个带有looper的线程,进行looper循环;looper对象可以用于创建Handler类来进行来进行调度,必须调用start()方法,Thread会先调用run方法来创建Looper对象。源码如下:

public void run() {
    mTid = Process.myTid();
    Looper.prepare();
    synchronized (this) {
        mLooper = Looper.myLooper();
        notifyAll();
    }
    Process.setThreadPriority(mPriority);
    onLooperPrepared();
    Looper.loop();
    mTid = -1;
}

创建HandlerThread很简单,它有两个构造函数,第一个构造函数只需要传递线程名称即可,第二构造函数除了线程名称,还需要设置优先级的功能

HandlerThread thread = new HandlerThread("downImage");
thread.start();

HandlerThread thread = new HandlerThread("downImage", Process.THREAD_PRIORITY_BACKGROUND);
thread.start();

需要注意的是,HandlerThread的run是一个无限循环,因此明确不需要它时,需要调用quit和quitSafely方法来终止线程的执行。

4、IntentService

IntentService继承了Service,并且它是一个抽象类,因此必须创建它的子类才能使用IntentService。它用于执行后台耗时的任务,执行完会自动停止。它拥有较高的优先级,不易被系统杀死(继承自Service的缘故),因此比较适合执行一些高优先级的异步任务。
IntentService其实还是由HandlerThread和Handler实现的。

@Override
public void onCreate() {
    // TODO: It would be nice to have an option to hold a partial wakelock
    // during processing, and to have a static startService(Context, Intent)
    // method that would launch the service & hand off a wakelock.

    super.onCreate();
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();

    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

onCreate中创建了一个HandlerThread ,在通过HandlerThread创建了一个Handler。startService后,最终会调用onStart方法。

@Override
public void onStart(@Nullable Intent intent, int startId) {
    Message msg = mServiceHandler.obtainMessage();
    msg.arg1 = startId;
    msg.obj = intent;
    mServiceHandler.sendMessage(msg);
}

从上面可以看出,mServiceHandler 发送的消息最终都会在HandlerThread 执行,会将Intent的对象传递给onHandleIntent抽象方法(需要子类实现)处理。onHandleIntent处理完之后会调用stopSelf(int startId)方法尝试停止服务,而不是stopSelf()来立即停止服务。下面创建一个示例看看它是怎样实现的。

public class DownLoadService extends IntentService {

    public DownLoadService(String name) {
        super(name);
    }

    @Override
    protected void onHandleIntent(@androidx.annotation.Nullable @Nullable Intent intent) {
        String url = intent.getStringExtra("url");
        Bitmap bitmap = dowload(url);
        // 保存逻辑处理
    }
}

启动跟Service一样

Intent intent = new Intent(this, DownLoadService.class);
startService(intent);

你可能感兴趣的:(Android,随笔)