android里的线程

ゝ一纸荒年。 2022-06-06 00:47 74阅读 0赞

> android里的线程 AsyncTask(封装了Thread和Handler,采用了线程池),IntentService, HandlerThread和一些常用的线程池

*  **线 程**

> **1.AsyncTask**  
> 有采用线程池，封装了Thread和Handler

采用`ThreadPoolExecutor`线程池：

public abstract class AsyncTask<Params, Progress, Result>
    
      /** * An { @link Executor} that can be used to execute tasks in parallel. */
        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;
        }

**实际项目中怎么用AsyncTask？**

![这里写图片描述][SouthEast]

**如图：模拟了一个下载文件的任务**

现在开始表演：

package com.yw.threaddemo;
    
    import android.app.Dialog;
    import android.app.ProgressDialog;
    import android.content.Context;
    import android.os.AsyncTask;
    import android.view.View;
    import android.widget.TextView;
    
    /** * Created by yw on 17/10/25. * author jackyang * com.yw.threaddemo */
    public class AsyncTaskDemo extends AsyncTask<String, Integer, String> { 
        private Context mContext;
        private View mView;
        private Dialog mDialog;
    
        public AsyncTaskDemo(Context context, View view) {
            this.mContext = context;
            this.mView = view;
        }
    
        @Override
        protected void onPreExecute() {
            //在ui线程中执行，ps：先弹一个加载框 表示你正在处理
            super.onPreExecute();
            mDialog =
                    new ProgressDialog(mContext);
            mDialog.setTitle("我是一个等待Dialog");
            mDialog.setCancelable(false);
            mDialog.show();
        }
    
        @Override
        protected void onPostExecute(String s) {
            //在ui线程中执行
            super.onPostExecute(s);
            mDialog.dismiss(); //关闭加载框
            ((TextView)mView).setText(s);
        }
    
        @Override
        protected void onProgressUpdate(Integer... values) {
            //当进度发生改变时，在ui线程中执行
            super.onProgressUpdate(values);
            //模拟 进度
            ((TextView)mView).setText("下载的进度是" + values[0] + "/10");
        }
    
        @Override
        protected void onCancelled(String s) {
            //在ui中执行，当任务被取消时执行
            super.onCancelled(s);
        }
    
        @Override
        protected String doInBackground(String... params) {
            //在子线程中执行 返回result onPostExecute得到回调的结果
            try {
               // Thread.sleep(10000); //模拟task
                for (int i = 0; i < 10; i++) {
                    publishProgress(new Integer(i));
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "我是返回的数据";
        }
    }

主线程里创建和执行task
    
     new AsyncTaskDemo(this, tv_show_result).execute("yw"); //创建和执行task

> **注意事项：**
> 
>  *  AsyncTask必须在主线程里创建
>  *  execute()必须在主线程里调用

源码下载地址

> **2.HandlerThread**   
> 继承Thread，可以使用handler的Thread；run()方法里会Looper.prepare()创建一个消息队列，并且开启消息循环Looper.loop();

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

> **3.IntentService**  
> 采用了HandlerThread

public abstract class IntentService extends Service . . . @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);
        .
        .
        .
    }

**来一个例子吧**

> 首先实现一个具体的 Service

package com.yw.threaddemo;
    
    import android.app.IntentService;
    import android.content.Intent;
    import android.util.Log;
    
    /** * Created by yw on 17/10/25. * author jackyang * com.yw.threaddemo */
    public class IntentServiceDemo extends IntentService { 
        /** * Creates an IntentService. Invoked by your subclass's constructor. * * @param name Used to name the worker thread, important only for debugging. */
        public IntentServiceDemo(String name) {
            super(name);
        }
    
        public IntentServiceDemo() {
            super("yw");
        }
        @Override
        protected void onHandleIntent(Intent intent) {
            String hint = intent.getStringExtra("hint");
            Log.d("yw", hint);
        }
    
        @Override
        public void onDestroy() {
            Log.d("yw", "onDestroy");
            super.onDestroy();
        }
    }

> 然后在Activity里调用  
> startService(Intent intent)

Intent i = new Intent(this, IntentServiceDemo.class);
            i.putExtra("hint", "666");
            startService(i);
            i.putExtra("hint", "777");
            startService(i);

> log如下  
> ![这里写图片描述][SouthEast 1]
> 
> 从日志中看到onDestroy方法只执行了一次， why？

* @see android.os.AsyncTask
     */
    public abstract class IntentService extends Service { 
        private volatile Looper mServiceLooper;
        private volatile ServiceHandler mServiceHandler;
        private String mName;
        private boolean mRedelivery;
    
        private final class ServiceHandler extends Handler { 
            public ServiceHandler(Looper looper) {
                super(looper);
            }
    
            @Override
            public void handleMessage(Message msg) {
                onHandleIntent((Intent)msg.obj);
                stopSelf(msg.arg1);   //源码中发现该方法，他会根据队列的里的服务是否都执行完了，再判断是否停止该服务
            }
        }
           .
           .
           .
    }

> demo下载地址

*  **线程池**

> 避免线程的重复创建和销毁，从而减小内存的消耗

1.  ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                     int maximumPoolSize,
                     long keepAliveTime,
                     TimeUnit unit,
                     BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                 threadFactory, defaultHandler);
        }

1.  FixedThreadPool

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

1.  CachedThreadPool

*Executors.class*
    
    public static ExecutorService newCachedThreadPool() {
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        }

[SouthEast]: /images/20220606/315d4e8ca2e7410aa99edea8c07a0c43.png
[SouthEast 1]: /images/20220606/0004e2289c454db7b12ac093d222def9.png