Android学习笔记：更新UI的方法（UI线程和非UI线程）

一、UI线程以及Android的单线程模型原则

当应用启动时，系统会创建一个主线程（Main Thread）。这个主线程负责向UI组件分发事件（包括绘制事件），在这个主线程里，应用和Android的UI组件发生交互。所以Main Thread也叫UI Thread也即UI线程。

系统不会为每个组件单独创建线程，在同一个进程里的UI组件都会在UI线程里实例化，系统对每一个组件的调用都从UI线程分发出去。结果就是在响应系统回调的方法永远都是在UI线程里运行。当App做一些比较重的工作的时候，除非你合理地实现，否则单线程模型的性能会很差。

特别的是，如果所有的工作都在UI线程，做一些比较耗时的工作比如访问网络或数据库查询，都会阻塞UI线程，导致事件停止分发（包括绘制事件）。对于用户来说，应用看起来像是卡住了，更坏的情况是，如果UI线程blocked的时间太长（大约超过5秒），用户就会看到ANR（Application Not Responding）的对话框。

此外，Android UI工具包并不是线程安全的，所以不能从非UI线程来操纵UI组件。必须把所有UI操作放在UI线程里。所以Android单线程模型有两条原则：
（1）不要阻塞UI线程。
（2）不要在UI线程之外访问Android UI工具包。（主要是这两个包中的组件：android.widget和android.view）

二、使用Worker线程

根据单线程模型的两条原则，首先，要保证应用的响应性，不能阻塞UI线程，所以当你的操作不是即时的那种，你应该把他们放在单另的线程中（叫做background或者work线程）。

例如：比如点击按钮后，下载一个图片然后在ImageView中展示：

public void onClick(View v){
	new Thread(new Runnable(){
		public void run(){
			Bitmap b = loagImageFromNetwork("http://example.com/image.png");
			mImageView.setImageBitmap(b);
		}
	}).start();
}

上面这段代码用新的线程来处理网络操作，但是它违反了第二条原则：Do not access the Android UI toolkit from outside the UI thread.（从非UI线程访问UI组件会导致未定义和不能预料的行为。）

三、交互方式

Android提供了一些方法，用于实现后台线程与UI线程的交互。

1、Handler（线程间通讯）（推荐）

在Android中我们一般用Handler做主线程和子线程之间的通信。Handler是Android中专门用来在线程之间传递信息类的工具。

原理：Handler的作用是将一个任务切换到某个指定的线程中去执行。系统之所以提供Handler，主要原因就是为了解决在子线程中无法访问UI的矛盾。（需要注意的是，Handler并不是专门用于更新UI的，它只是常被开发者用来更新UI。）

关于Handler的具体分析，请点击跳转。

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    public static final int UPDATE_TEXT = 1;

    private TextView textView;

    private Buttion button;

	//在主线程中定义接收函数
    private Handler handler = new Handler(){
        //重写父类handleMessage()方法
        public void handleMessage(Message msg){
            switch(msg.what){
                case UPDATE_TEXT:
                    //在这里可以进行UI操作
                    textView.setText("更新");
                    break;
                default:
                    break;
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView)findViewById(R.id.tv);
        button = (Buttion)findViewById(R.id.btn);
        button.setOnClickListener(this);
    }

    @Override
    public void onClick(View v){
        switch(v.getId()){
            case R.id.btn:
                new Thread(new Runnable(){
                    @Override
                    public void run(){
                        Message message = new Message();
                        message.what = UPDATE_TEXT;
                        handler.sendMessage(message);//将Message对象发送出去
                    }
                }).start();
                break;
            default:
                break;
        }
    }
}

2、AsyncTask利用线程任务异步更新UI界面（推荐）

AsyncTask是一个专门用来处理后台进程与UI线程的工具。

关于AsyncTask的具体分析，请点击跳转。

AsyncTask有4个重要的回调方法：
（1）onPreExecute()，onPreExecute运行在UI线程，主要目的是为后台线程的运行做准备。当它运行完后，会调用doInBackground方法。（这个方法会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作。）
（2）doInBackground()，doInBackground运行在后台线程，用来负责运行任务，它拥有参数params，并且返回Result。在后台线程的运行当中，为了能够更新作业完成的进度，需要在doInBackground方法中调用publishProgress方法。该方法拥有参数params，通过该方法可以更新progress数据，然后当调用完publishProgress方法，它会调用onProgressUpdate方法用于更新进度。（这个方法中的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。注意，在这个方法是不可以进行UI操作的，如果需要更新UI元素，比如说反馈当前任务的执行进度，可以调用publishProgress(Progress…)方法来完成）
（3）onProgressUpdate()，onProgressUpdate运行在UI线程，主要目的是用来更新UI线程中显示进度的UI控制。它拥有Progress参数，在doInBackground中调用PublishProgress之后，就会自动调onProgressUpdate方法。（在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。）
（4）onPostExecute()，onPostExecute运行在UI线程，当doInBackground方法运行完后，它会调用onPostExecute方法，并传入Result。在onPostExecute方法中，就可以将Result更新到UI控件上。（当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用反回的数据来进行一些UI操作。）

一个比较完整的自定义AsyncTask就可以写成如下方式：

class MyAsyncTask extends AsyncTask<String, Void, Boolean>(){
	
	@Override
	protected Boolean doInBackground(Void... params){
		return null;
	}
	
	@Override
	protected void onPreExecute(){
		super.onPreExecute();
	}

	@Override
	protected void onPostExecute(Boolean result){
		super.onPostExecute(result);
	}

	@Override
	protected void onProgressUpdate(Integer...values){
		super.onProgressUpdate(values);
	}
}

原理：调用UI线程中的Handler。AsyncTask是对Handler与线程池的封装。使用它的方便之处在于能够更新用户界面，当然这里更新用户界面的操作还是在主线程中完成的，但是由于AsyncTask内部包含一个Handler，所以可以发送消息给主线程让它更新UI。另外，AsyncTask内还包含了一个线程池。使用线程池的主要原因是避免不必要的创建及销毁线程的开销。

注意：AsyncTask实例只能执行一次，否则就会出错。

项目简介：使用AsyncTask来更新UI界面
项目地址：https://github.com/ambition-hb/UsingAsyncTask

部分代码如下：

public class MainActivity extends AppCompatActivity {

    private TextView text;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text = (TextView)findViewById(R.id.textView);
        findViewById(R.id.read).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ReadURL("http://www.baidu.com");
            }
        });
    }

    public void ReadURL(String url){
        new AsyncTask<String, Void, String>() {
            @Override
            protected String doInBackground(String... params) {
                try {
                    URL url = new URL(params[0]);
                    URLConnection connection = url.openConnection();
                    InputStream iStream = connection.getInputStream();
                    InputStreamReader isr = new InputStreamReader(iStream);
                    BufferedReader br = new BufferedReader(isr);
                    String line;
                    StringBuilder builder = new StringBuilder();
                    while((line=br.readLine()) != null){
                        builder.append(line);
                    }
                    br.close();
                    iStream.close();
                    return builder.toString();
                } catch (MalformedURLException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }

            @Override
            protected void onPreExecute() {
                super.onPreExecute();
            }

            @Override
            protected void onProgressUpdate(Void... values) {
                super.onProgressUpdate(values);
            }

            @Override
            protected void onPostExecute(String s) {
                text.setText(s);
                super.onPostExecute(s);
            }
        }.execute(url);
    }
}

3、利用Runnable更新UI界面

（1）Activity.runOnUiThread(Runnable)

原理：调用UI线程中的Handler。首先在主线程里通过无参的构造方法创建一个Handler，这个Handler是指向主线程的。当执行runOnUiThread()时，当前线程不是主线程，调用mHandler.post(action)，将Runnable添加到主线程的消息队列中 。利用Activity.runOnUiThread(Runnable)把更新ui的代码创建在Runnable中，然后在需要更新ui时，把这个Runnable对象传给Activity.runOnUiThread(Runnable)。runOnUiThread()方法将线程切换到主线程，Runnable对象就能在ui程序中被调用。如果当前线程是UI线程，那么行动是立即执行。如果当前线程不是UI线程，操作是发布到事件队列的UI线程。

步骤：
（1）编写后台线程，可直接调用UI控件
（2）创建后台线程实例
（3）调用UI线程对应的Activity的runOnUiThread方法，将后台线程实例作为参数传入其中
注：无需调用后台线程的start方法

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private TextView textView;
    private Buttion button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView)findViewById(R.id.tv);
        button = (Buttion)findViewById(R.id.btn);
        button.setOnClickListener(this);
    }

    @Override
    public void onClick(View v){
        switch(v.getId()){
            case R.id.btn:
                new Thread(new Runnable(){
                    @Override
                    public void run(){
                        //耗时操作
                        runOnUiThread(new Runnable(){
                            @Override
                            public void run(){
                                textView.setText("更新");
                            }
                        });
                    }
                }).start();
                break;
            default:
                break;
        }
    }
}

（2）View.Post(Runnable)

原理：调用UI线程中的Handler。View的post方法，它的作用是将Runnable加到message queue中，然后在UI线程执行。（该方法与方法（1）基本相同，只是在后台线程中能操控的UI控件被限制了，只能是指定的UI控件view。）

步骤：
（1）编写后台线程，可直接调用UI控件，但是该UI控件只能是view
（2）创建后台线程的实例
（3）调用UI控件view的post方法，将后台线程实例作为参数传入其中

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private TextView textView;

    private Buttion button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.tv);
        button = (Buttion) findViewById(R.id.btn);
        button.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn:
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        textView.post(new Runnable(){
                            @Override
                            public void run(){
                                textView.setText("更新");
                            }
                        });
                    }
                }).start();
                break;
            default:
                break;
        }
    }
}

（3）View.PostDelayed(Runnable, Long)

原理：调用UI线程中的Handler。（该方法是方法（2）的补充，long参数用于制定）

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private TextView textView;

    private Buttion button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.tv);
        button = (Buttion) findViewById(R.id.btn);
        button.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn:
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        textView.postDelayed(new Runnable(){
                            @Override
                            public void run(){
                                textView.setText("更新");
                            }
                        }, 2000);
                    }
                }).start();
                break;
            default:
                break;
        }
    }
}

注意：
（1）一些组件本身就有提供方法来更新自己，像是ProgressBar本身就有一个post()方法，只要我们传进一个Runnable对象，就能更新它的进度。
（2）只要是继承自View的组件，都可以利用post()方法，而且还可以使用postDelay()方法来延迟执行该Runnable对象。

四、小结

总结：
（1）如果只是单纯的想要更新UI而不涉及到多线程的话，可以使用View.post()就可以了。
（2）需要另开线程处理数据以免阻塞UI线程，像是IO操作或者是循环，可以使用Activity.runOnUiThread()。
（3）如果需要传递状态值等信息，像是蓝牙编程中的socket连接，就需要利用状态值来提示连接状态以及做相应的处理，就需要使用Handler+Thread的方式。
（4）如果是后台任务，像是下载任务等，就需要使用AsyncTask。

问题：
为什么Android要求只能在UI线程进行UI操作？
Android的UI是线程不安全的，存在并发访问的问题。加锁也不合适：
（1）加锁会让UI访问的逻辑变复杂
（2）加锁会降低UI访问的效率，因为锁会阻塞某些线程的执行
更主要原始是为了避免多线程造成的并发的问题。在单线程操作UI是安全的。

参考资料: Android的UI线程和非UI线程.
参考资料: Android的UI线程和非UI线程的交互方法.