Android 多線程處理之多線程用法大集合

時間 2019-12-19

原文原文鏈接

1.handler.post(r)

其實這樣並不會新起線程，只是執行的runnable裏的run()方法，卻沒有執行start()方法，因此runnable走的仍是UI線程。java

若是像這樣，是能夠操做ui,可是run仍是走在主線程，見打印出來的Log線程名字是main，說明是主線程。android

這就是爲何能夠直接在run方法裏操做ui,由於它本質仍是ui線程多線程

handler.post(new Runnable(){

　　public void run(){

　　    Log.e("當前線程：",Thread.currrentThread.getName());//這裏打印de結果會是main

　　    setTitle("哈哈");

   }
});

2.HandlerThread

經過HandlerThread獲取到looper倒是能夠新起線程，可是在這裏的run方法裏操做ui是不可能的，可是這顯然有個缺點，若是你執行屢次post(r)方法其實走的仍是HandlerThread線程。假如你執行5次，n次，其實仍是一次而且它們是串行的。假以下載5張圖片，你會看到圖片是下完第一張，纔會去下第二張。架構

實踐證實，只有是擁有主線程looper的handler才能夠操做ui,而在主線程操做ui能夠在handler的handlerMessage()方法中操做Ui,也能夠在handler的post(r)的run方法裏操做Ui.app

HandlerThread ht = new HandlerThread("handler thread");

ht.start();

handler = new Handler(ht.getLooper());

handler.post(new Runnable(){//這裏run()方法其實仍是在等ht.start()調用

　　public void run(){

　　    Log.e("當前線程：",Thread.currrentThread.getName());//這裏打印的會是handler thread

　　    setTitle("哈哈");//這樣一定報錯

　　    //Android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

   }

});

這樣該怎麼辦呢，呵呵，能夠無參構建一個handler。用這個handler來發送消息和處理消息，用上面的handler來開啓新線程。異步

mainHandler = new Handler(){

　　protecket void handlerMessage(Message msg){

　　　　setTitle("哈哈");//這樣就不會報錯啦

　　}

}

handler.post(new Runnable(){//這裏run()方法其實仍是在等ht.start()調用

　　public void run(){

　　Log.e("當前線程：",Thread.currrentThread.getName());//這裏打印的會是handler thread

　　mainHandler.sendEmpetMessage();//用mainHandler來發送消息

　　//setTitle("哈哈");//這樣一定報錯

　　//android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

      }

});

打印Log:ide

3.更好的方法

其實第2個方法顯得麻煩並且低效，用了2個handler，一個用來發起線程，一個用於處理消息。發起線程的handler必須擁有looper，因此還要實例化一個HanderThread；而處理消息的handler則不須要looper，由於它默認擁有主線程的looper，因此能夠在這個handler處理ui。oop

其實能夠只須要實例化一個handler，在主線程裏構建一個無參的handler，而後由它發送和處理消息。而建立線程的任務就不用handler了，直接用new Thread(r).start();而後在r的run()方法裏面處理邏輯事務。post

用這樣的模式下載5張圖片，你就可能不會看到圖片一張挨着一張展現出來，可能第2張先出來，也可能同時出來3張，5條線程很隨機的。ui

private void loadImagesByThread(final String url,final int id){//經過Thread來new 出多個線程  
          
        new Thread(new Runnable(){  
  
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                Log.e("當前線程：", ""+Thread.currentThread().getName());  
                Drawable drawable = null;  
                try {  
                    drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
                } catch (MalformedURLException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                Message msg = mainHandler.obtainMessage();  
                msg.what = 2012;  
                msg.arg1 = id;  
                msg.obj = drawable;  
                msg.sendToTarget();  
                  
            }  
              
        }).start();  
    }

打印Log:

4.AsyncTask

用異步任務架構多任務模型其實也不是很健壯，得建立多個AsyncTask實例。一個AsyncTask僅執行一次，不能重複執行，快餐類的線程，一次用完。

實現AsyncTask子類，最重要的兩個方法，一個是doInBackground(params);一個是onPostExecute(result)。在doInBackground()方法裏處理耗時事務，並把結果返回，返回的值將在onPostExecute方法做爲參數，而後就能夠在onPostExecute()把結果展現在ui上面了。

步驟：

①實例化AsyncTask：

實例化AsyncTask而後經過task.exec(pamas);傳進去參數，這個參數列表是動態的，能夠是一個也可使多個，長度可變。

　　AsyncTask<params,values,reslut>,第一個參數會傳進去這個方法doInBackground(params)，第二個參數是數據更新的值，第三個是處理事務返回的結果。

②onPreExecute方法：

這個方法沒有參數，也沒有返回值，能夠在這個方法裏，作一些提醒。好比show一個Dialog，或者彈個Toast告訴用戶開始下載啦。

③doInBackground(params)方法:

進入AsyncTask內部結構，首先將執行reslut doInBackground(params)方法，這個方法將處理耗時事務，exec()的參數將會傳進這個方法作參數，而返回值將會做爲onPostExecute()的參數。若是要更新進度的話，需執行publicProgress()方法。

④onProgressUpdate(values)方法：

這個方法的參數必須在doInBackground()方法裏執行publicProgress()方法，這個方法將會把參數傳遞進onProgressUpdate()方法裏，而後能夠在這個方法作一些ui上的更新展現，好比進度條的值就能夠經過這個values值動態改變。

⑤onPostExecute(result)方法：

這裏就是事務處理完畢的走的方法，doInBackground方法執行的結果將傳到這裏，若是這個方法返回了數據。在這個方法裏能夠處理Ui，能夠把處理完的數據展現在ui上。好比圖片啊，文字啊，一切你想要的結果。

private void loadImageByAsyncTask(final String url,final int id){//構建異步任務，這樣就不用handler來處理消息了  
        DownloadTask task = new DownloadTask();  
        task.execute(""+id,url);//AsyncTask不可重複執行  
    }  
      
    class DownloadTask extends AsyncTask<String,Integer,Drawable>{  
  
        int id;  
        @Override  
        protected Drawable doInBackground(String... params) {//params保存url和控件id兩個數據  
            // TODO Auto-generated method stub  
            Log.e("當前線程：", ""+Thread.currentThread().getName());  
            Drawable drawable = null;  
            this.id = Integer.parseInt(params[0]);  
            try {  
                drawable = Drawable.createFromStream(new URL(params[1]).openStream(), "image.gif");  
            } catch (MalformedURLException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
              
            return drawable;  
        }  
  
        @Override  
        protected void onPostExecute(Drawable result) {  
            // TODO Auto-generated method stub  
            super.onPostExecute(result);  
            ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(result);  
        }  
  
        @Override  
        protected void onPreExecute() {  
            // TODO Auto-generated method stub  
            super.onPreExecute();  
        }  
  
        @Override  
        protected void onProgressUpdate(Integer... values) {  
            // TODO Auto-generated method stub  
            super.onProgressUpdate(values);  
        }  
  
          
    }

這裏打印的log

5.ExecutorServie線程池

經過Executors的靜態方法來建立，通常有三種：

1.單線程：Executors.newSingleThreadExecutor();

2.固定數量線程：Executors.newFixedThreadPool();

3.動態線程：Executors.newCachedThreadPool();

這裏咱們用固定5個線程來應用，使用方法是建立ExecutorService對象，而後執行submit(r)能夠發起一個Runnable對象。用線程池來管理的好處是，能夠保證系統穩定運行，適用與有大量線程，高工做量的情景下使用，假如要展現1000張圖片若是建立1000個線程去加載，保證系統會死掉。用線程池就能夠避免這個問題，能夠用5個線程輪流執行，5個一組，執行完的線程不直接回收而是等待下次執行，這樣對系統的開銷就能夠減少很多。

private void loadImagesByExecutors(final String url,final int id){  
        service.submit(new Runnable(){  
              
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                Log.e("當前線程：", ""+Thread.currentThread().getName());  
                  
                try {  
                    final Drawable drawable  = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
                    mainHandler.post(new Runnable(){  
  
                        @Override  
                        public void run() {//這將在主線程運行  
                            // TODO Auto-generated method stub  
                            ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable);  
                        }  
                    });  
                      
                } catch (MalformedURLException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                  
            }  
              
        });  
          
    }

Log:

其實可能沒有說清楚，第一種不算多線程。

1.loadImagesByHandler()是經過Handler.post()方法，構建兩個Handler進行通訊。

2.loadImagesByThread()，這個是直接new Thread()發起線程，在主線程的handler處理消息

3.loadImageByAsyncTask(),這個用的是異步任務，全部實如今它的內部結構裏，能夠在裏頭操做Ui.

4.loadImagesByExecutors()用的是線程池，使得線程可控，保證穩定運行。

其實經常使用的就是後三種，第二個用法靈活，簡單，但不適宜大數量任務；第三個通常適用於單個任務，一次性任務；第四個通常用於大數量，高密度執行的使用情景，好比批量加載圖片，批量下載文件等。

看一眼圖吧：

所有源碼：

package com.bvin.exec;  
  
import java.io.IOException;  
import java.net.MalformedURLException;  
import java.net.URL;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
import android.app.Activity;  
import android.graphics.drawable.Drawable;  
import android.os.AsyncTask;  
import android.os.Bundle;  
import android.os.Handler;  
import android.os.HandlerThread;  
import android.os.Message;  
import android.util.Log;  
import android.view.View;  
import android.widget.Button;  
import android.widget.ImageView;  
  
public class MainActivity extends Activity {  
    /** Called when the activity is first created. */  
      
    private Handler handler ;  
    private Button bt;  
    private Handler mainHandler = new Handler(){  
  
        @Override  
        public void handleMessage(Message msg) {  
            // TODO Auto-generated method stub  
            super.handleMessage(msg);  
            if(msg.what == 2012){  
                //只要在主線程就能夠處理ui   
                ((ImageView)MainActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);  
            }  
        }  
          
          
    };  
      
    private ExecutorService service = Executors.newFixedThreadPool(5);  
      
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
        initViews();  
        HandlerThread ht = new HandlerThread("down image thread");  
        ht.start();  
        handler = new Handler(ht.getLooper()){//若是有了looper那麼這個handler就不能夠處理ui了  
  
            @Override  
            public void handleMessage(Message msg) {  
                // TODO Auto-generated method stub  
                super.handleMessage(msg);  
                  
                  
            }  
              
        };  
          
    }  
      
    private void initViews(){  
          
        bt = (Button)findViewById(R.id.bt);  
        bt.setOnClickListener(new View.OnClickListener() {  
              
            @Override  
            public void onClick(View v) {  
                // TODO Auto-generated method stub  
                loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/23c1625aca99f02c50d8e510383a34e7.jpg",R.id.iv1);  
                loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/c4698d97ef6d10722c8e917733c7beb3.jpg",R.id.iv2);  
                loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/f332ffe433be2a3112be15f78bff5a40.jpg",R.id.iv3);  
                loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/6ff8a9c647a1e80bc602eeda48865d4c.jpg",R.id.iv4);  
                loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/f104d069f7443dca52a878d779392874.jpg",R.id.iv5);  
            }  
        });  
    }  
      
    private void loadImagesByHandler(final String url,final int id){//經過擁有looper的handler.post(runnable)，新建線程  
          
          
        handler.post(new Runnable(){//若是handler沒有Looper那麼它就不能構建新線程了  
  
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                Log.e("當前線程：", ""+Thread.currentThread().getName());  
                Drawable drawable = null;  
                try {  
                    drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
                } catch (MalformedURLException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                //SystemClock.sleep(2000);  
                //((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable);  
                Message msg = mainHandler.obtainMessage();  
                msg.what = 2012;  
                msg.arg1 = id;  
                msg.obj = drawable;  
                msg.sendToTarget();  
            }  
              
        });  
          
          
    }  
      
    private void loadImagesByThread(final String url,final int id){//經過Thread來new 出多個線程  
          
        new Thread(new Runnable(){  
  
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                Log.e("當前線程：", ""+Thread.currentThread().getName());  
                Drawable drawable = null;  
                try {  
                    drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
                } catch (MalformedURLException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                Message msg = mainHandler.obtainMessage();  
                msg.what = 2012;  
                msg.arg1 = id;  
                msg.obj = drawable;  
                msg.sendToTarget();  
                  
            }  
              
        }).start();  
    }   
  
    private void loadImageByAsyncTask(final String url,final int id){//構建異步任務，這樣就不用handler來處理消息了  
        DownloadTask task = new DownloadTask();  
        task.execute(""+id,url);//AsyncTask不可重複執行  
    }  
      
    private void loadImagesByExecutors(final String url,final int id){  
        service.submit(new Runnable(){  
              
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                Log.e("當前線程：", ""+Thread.currentThread().getName());  
                  
                try {  
                    final Drawable drawable  = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
                    mainHandler.post(new Runnable(){  
  
                        @Override  
                        public void run() {//這將在主線程運行  
                            // TODO Auto-generated method stub  
                            ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable);  
                        }  
                    });  
                      
                } catch (MalformedURLException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                  
            }  
              
        });  
          
    }  
      
    class DownloadTask extends AsyncTask<String,Integer,Drawable>{  
  
        int id;  
        @Override  
        protected Drawable doInBackground(String... params) {//params保存url和控件id兩個數據  
            // TODO Auto-generated method stub  
            Log.e("當前線程：", ""+Thread.currentThread().getName());  
            Drawable drawable = null;  
            this.id = Integer.parseInt(params[0]);  
            try {  
                drawable = Drawable.createFromStream(new URL(params[1]).openStream(), "image.gif");  
            } catch (MalformedURLException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
              
            return drawable;  
        }  
  
        @Override  
        protected void onPostExecute(Drawable result) {  
            // TODO Auto-generated method stub  
            super.onPostExecute(result);  
            ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(result);  
        }  
  
        @Override  
        protected void onPreExecute() {  
            // TODO Auto-generated method stub  
            super.onPreExecute();  
        }  
  
        @Override  
        protected void onProgressUpdate(Integer... values) {  
            // TODO Auto-generated method stub  
            super.onProgressUpdate(values);  
        }  
  
          
    }  
}