美文网首页
Android线程

Android线程

作者: fomin | 来源:发表于2018-11-20 16:07 被阅读2次

    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> 
    

    其中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<String, Integer, String> {
    
        @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线程

          本文链接:https://www.haomeiwen.com/subject/oujxqqtx.html