線程 服務 Thread HandlerThread AsyncTask

一:線程和服務

之前有個需求,要求app在後臺可以接受和發送數據,接到這個需求,一直的想法都是如何保活服務,後來悲催的發現,服務保活很難,線程卻可以長久存在,所以如果大家有遇到類似的需求,就不要在服務上做文章了,搞個線程就搞定了,當然,如果你的需求是app後臺被清理也要可以接收發送數據,那麼可以找項目經理說一下,這個需求實現不了

二:線程三種開啓方式

我們使用線程的目的基本就是爲了是app在後臺的時候仍能進行操作,並且操作完成後能及時通知其他線程(這裏就是Handler的作用所在了,如果主要是通知主線程更改UI,runonuithread就可以了)

1.Thread+Handler Timer+Handler

創建Thread和創建Timer都是去開啓了一個線程

final Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                if (msg.what == 1) {
                    //這裏就是主線程,可以進行更新UI等操作
                    System.out.println("是在循環嗎========");
                }
                super.handleMessage(msg);

            }
        };

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);//每隔1s執行一次
                        Message msg = new Message();
                        msg.what = 1;
                        handler.sendMessage(msg);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        }).start();

    final Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 1) {
                //do something
            }
            super.handleMessage(msg);
        }
    };

    Timer timer = new Timer();
    TimerTask timerTask = new TimerTask() {
        @Override
        public void run() {
            //這裏如果只是更新UI,可以直接使用runonuithread
            Message message = new Message();
            message.what = 1;
            handler.sendMessage(message);
        }
    };

     //主線程中調用：
    timer.schedule(timerTask, 1000, 500);//延時1s，每隔500毫秒執行一次run方法

2.HandlerThread

HandlerThread的本質：繼承Thread類 & 封裝Handler類

說是可以簡化Thread+Handler方式的複雜操作,但如果你用習慣了Thread+Handler方式,也沒有必要非要用這個

實例:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    tools:context="com.example.carson_ho.handler_learning.MainActivity">


    <TextView
        android:id="@+id/text1"
        android:layout_centerInParent="true"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="測試結果" />

    <Button
        android:id="@+id/button1"
        android:layout_centerInParent="true"
        android:layout_below="@+id/text1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="點擊延遲1s + 顯示我愛學習"/>

    <Button
        android:id="@+id/button2"
        android:layout_centerInParent="true"
        android:layout_below="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="點擊延遲3s + 顯示我不愛學習"/>

    <Button
        android:id="@+id/button3"
        android:layout_centerInParent="true"
        android:layout_below="@+id/button2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="結束線程的消息循環"/>
</RelativeLayout>

public class MainActivity extends AppCompatActivity {

    Handler mainHandler,workHandler;
    HandlerThread mHandlerThread;
    TextView text;
    Button button1,button2,button3;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 顯示文本
        text = (TextView) findViewById(R.id.text1);

        // 創建與主線程關聯的Handler
        mainHandler = new Handler();

        /**
          * 步驟1：創建HandlerThread實例對象
          * 傳入參數 = 線程名字，作用 = 標記該線程
          */
        mHandlerThread = new HandlerThread("handlerThread");

        /**
         * 步驟2：啓動線程
         */
        mHandlerThread.start();

        /**
         * 步驟3：創建工作線程Handler & 複寫handleMessage（）
         * 作用：關聯HandlerThread的Looper對象、實現消息處理操作 & 與其他線程進行通信
         * 注：消息處理操作（HandlerMessage（））的執行線程 = mHandlerThread所創建的工作線程中執行
         */

         //注:這裏因爲設置了參數mHandlerThread.getLooper(),所以workHandler存在於子線程中,不可直接更新UI
        workHandler = new Handler(mHandlerThread.getLooper()){
            @Override
            // 消息處理的操作
            public void handleMessage(Message msg)
            {
                //設置了兩種消息處理操作,通過msg來進行識別
                switch(msg.what){
                    // 消息1
                    case 1:
                        try {
                            //延時操作
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        // 通過主線程Handler.post方法進行在主線程的UI更新操作
                        mainHandler.post(new Runnable() {
                            @Override
                            public void run () {
                                text.setText("我愛學習");
                            }
                        });
                        break;

                    // 消息2
                    case 2:
                        try {
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        mainHandler.post(new Runnable() {
                            @Override
                            public void run () {
                                text.setText("我不喜歡學習");
                            }
                        });
                        break;
                    default:
                        break;
                }
            }
        };

        /**
         * 步驟4：使用工作線程Handler向工作線程的消息隊列發送消息
         * 在工作線程中，當消息循環時取出對應消息 & 在工作線程執行相關操作
         */
        // 點擊Button1
        button1 = (Button) findViewById(R.id.button1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                // 通過sendMessage（）發送
                // a. 定義要發送的消息
                Message msg = Message.obtain();
                msg.what = 1; //消息的標識
                msg.obj = "A"; // 消息的存放
                // b. 通過Handler發送消息到其綁定的消息隊列
                workHandler.sendMessage(msg);
            }
        });

        // 點擊Button2
        button2 = (Button) findViewById(R.id.button2);
        button2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                // 通過sendMessage（）發送
                // a. 定義要發送的消息
                Message msg = Message.obtain();
                msg.what = 2; //消息的標識
                msg.obj = "B"; // 消息的存放
                // b. 通過Handler發送消息到其綁定的消息隊列
                workHandler.sendMessage(msg);
            }
        });

        // 點擊Button3
        // 作用：退出消息循環
        button3 = (Button) findViewById(R.id.button3);
        button3.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mHandlerThread.quit();
            }
        });

    }
    
}

3.AsyncTask

直接上案例

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center"
    tools:context="com.example.carson_ho.handler_learning.MainActivity">

    <Button
        android:layout_centerInParent="true"
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="點我加載"/>

    <TextView
        android:id="@+id/text"
        android:layout_below="@+id/button"
        android:layout_centerInParent="true"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="還沒開始加載!" />

    <ProgressBar
        android:layout_below="@+id/text"
        android:id="@+id/progress_bar"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:progress="0"
        android:max="100"
        style="?android:attr/progressBarStyleHorizontal"/>

    <Button
        android:layout_below="@+id/progress_bar"
        android:layout_centerInParent="true"
        android:id="@+id/cancel"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="cancel"/>
</RelativeLayout>

public class MainActivity extends AppCompatActivity {

    // 線程變量
    MyTask mTask;

    // 主佈局中的UI組件
    Button button,cancel; // 加載、取消按鈕
    TextView text; // 更新的UI組件
    ProgressBar progressBar; // 進度條
    
    /**
     * 步驟1：創建AsyncTask子類
     * 注：
     *   a. 繼承AsyncTask類
     *   b. 爲3個泛型參數指定類型；若不使用，可用java.lang.Void類型代替
     *      此處指定爲：輸入參數 = String類型、執行進度 = Integer類型、執行結果 = String類型
     *   c. 根據需求，在AsyncTask子類內實現核心方法
     */
    private class MyTask extends AsyncTask<String, Integer, String> {

        // 方法1：onPreExecute（）
        // 作用：執行 線程任務前的操作
        @Override
        protected void onPreExecute() {
            text.setText("加載中");
            // 執行前顯示提示
        }


        // 方法2：doInBackground（）
        // 作用：接收輸入參數、執行任務中的耗時操作、返回 線程任務執行的結果
        // 此處通過計算從而模擬“加載進度”的情況
        @Override
        protected String doInBackground(String... params) {

            try {
                int count = 0;
                int length = 1;
                while (count<99) {

                    count += length;
                    // 可調用publishProgress（）顯示進度, 之後將執行onProgressUpdate（）
                    publishProgress(count);
                    // 模擬耗時任務
                    Thread.sleep(50);
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            }

            return null;
        }

        // 方法3：onProgressUpdate（）
        // 作用：在主線程 顯示線程任務執行的進度
        @Override
        protected void onProgressUpdate(Integer... progresses) {

            progressBar.setProgress(progresses[0]);
            text.setText("loading..." + progresses[0] + "%");

        }

        // 方法4：onPostExecute（）
        // 作用：接收線程任務執行結果、將執行結果顯示到UI組件
        @Override
        protected void onPostExecute(String result) {
            // 執行完畢後，則更新UI
            text.setText("加載完畢");
        }

        // 方法5：onCancelled()
        // 作用：將異步任務設置爲：取消狀態
        @Override
        protected void onCancelled() {

            text.setText("已取消");
            progressBar.setProgress(0);

        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // 綁定UI組件
        setContentView(R.layout.activity_main);

        button = (Button) findViewById(R.id.button);
        cancel = (Button) findViewById(R.id.cancel);
        text = (TextView) findViewById(R.id.text);
        progressBar = (ProgressBar) findViewById(R.id.progress_bar);

        /**
         * 步驟2：創建AsyncTask子類的實例對象（即 任務實例）
         * 注：AsyncTask子類的實例必須在UI線程中創建
         */
        mTask = new MyTask();

        // 加載按鈕按按下時，則啓動AsyncTask
        // 任務完成後更新TextView的文本
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                /**
                 * 步驟3：手動調用execute(Params... params) 從而執行異步線程任務
                 * 注：
                 *    a. 必須在UI線程中調用
                 *    b. 同一個AsyncTask實例對象只能執行1次，若執行第2次將會拋出異常
                 *    c. 執行任務中，系統會自動調用AsyncTask的一系列方法：onPreExecute() 、doInBackground()、onProgressUpdate() 、onPostExecute()
                 *    d. 不能手動調用上述方法
                 */
                mTask.execute();
            }
        });

        cancel = (Button) findViewById(R.id.cancel);
        cancel.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 取消一個正在執行的任務,onCancelled方法將會被調用
                mTask.cancel(true);
            }
        });

    }

}

三:總結

1.Thread+Handler和HandlerThread並無特別大的優劣之分,使用哪個全憑個人喜好(因Timer+Handler自帶定時循環,所以常用Timer+Handler 和 HandlerThread)

2.AsyncTask 常用於下載操作

四:注意事項

1.使用Handler常會引起內存泄露,原因是handler爲非靜態內部類/匿名內部類,持有對外部類的引用,如果這時在Handler消息隊列 還有未處理的消息 / 正在處理消息時，消息隊列中的Message持有Handler實例的引用,就會引起內存泄露

解決方法:handler聲明爲靜態內部類或者及時清空消息隊列

2.AsyncTask也會引起內存泄露,原因是若AsyncTask被聲明爲Activity的非靜態內部類，當Activity需銷燬時，會因AsyncTask保留對Activity的引用 而導致Activity無法被回收，最終引起內存泄露

解決方法:聲明爲靜態內部類

注:該文章借鑑了Carson_Ho (強烈建議去逛逛這位大神的博客,條理清晰,簡單易懂)

https://blog.csdn.net/carson_ho/article/details/79285760

https://blog.csdn.net/carson_ho/article/details/79314325