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);  
        }  
  
          
    }  
}