Android中的 事件流----浅析安卓中的动与静（三） 线程间通讯

任何程序都是静态代码，我们把这些静态代码打包好，然后放到运行环境当中，通过事件流的驱动使这些代码运行起来。Android的环境也不例外。

静态的代码，在动态事件的驱动下，才会有效的运转起来。

驱动Android程序运行起来的事件大致可以分为以下几种：

用户事件：如点击屏幕，滑动等各种手势；

系统事件：如屏幕方向的转变；

线程通讯事件：线程之间互发消息，程序根据消息内容进行相应的响应；

进程通讯事件：这里的进程包括本程序开启的进程，也包括其他应用程序的进程。

下面来介绍动态事件驱动的第三种：线程通讯事件流

线程通讯事件流

线程通讯也是造成Android动态化的一个重要方面，当一个UI主线程收到其他线程发过来的消息，可以动态更改自己的页面。

下面总结下线程之间通讯的几种方式：

（从重要性和实用角度排序）

1.使用Handler实现

2.使用AsyncTask

3.Activity.runOnUiThread(Runnbale)

4.View.post(Runnbale)

5.View.postDelayed(Runnalbe,long)

2-5其实内部实现都是Handler。

下面一一介绍用法：

1.使用Handler实现

先来讲Handler的实现，因为后边的四个都是基于Handler的实现的，谈到Handler的运行机制，不得不提Looper、Message、MessagerQueue了，它们之间的关系，下边这个图片描述的很清楚了。

用一句话总结就是在主线程中定义Handler对象，然后在子线程中调用这个Handler对象将封装好的Message对象发送到主线程中Looper管理的MessageQueue中。上边两句话是说在子线程中向主线程发送消息。那我如果想从主线程向子线程发送消息呢？或者子线程之间发送消息呢？其实还是一个道理。线程A要想给线程B发送消息，就要获取线程B中的Handler对象，然后通过此对象向线程B中的Looer中的MessageQueue中发送消息。注意，Looper和Handler是一一对应的。一个handler只能向其所在的线程发送Message消息。只不过UI线程的Looper是自动启动好的，其他线程要想享受到Looper的服务，必须通过 Looper.prepare()和Looper.loop();自行启动。下边写了一个demo，以后可以学习参考：

public class MainActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
	    final Handler mHandler=new Handler();
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		final MyButton er=(MyButton) findViewById(R.id.ddd);
		Log.v("onCreate",	 "onCreate");
		er.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				Log.v("onClick",	 v.toString());
				Intent sub= new Intent(MainActivity.this, SubActivity.class);
				startActivity(sub);
				
			}
		});


        final Myrunnable murMyrunnable=new Myrunnable();

        new Thread(murMyrunnable).start();
        
        
        
        new Thread(new Runnable() {

 
            


                //延迟两秒


            	 public Handler mHandler;

                 public void run() {

                                 Looper.prepare();
                                 Looper.loop();

                                 mHandler = new Handler() {

                                                 public void handleMessage(Message msg) {

                                                	 Toast.makeText(MainActivity.this, "wewe"+msg.what, Toast.LENGTH_SHORT).show();
                                                 }

                                 };

                             


            }

        }).start();

        //创建一个线程

        new Thread(new Runnable() {

 

            @Override

            public void run() {

 

                //延迟两秒


                try {

                    Thread.sleep( 5000 );

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

 

             
                 mHandler.post(new Runnable() {
                	 //
                   @Override

                   public void run() {
                   	er.setText("变了");
                       Toast.makeText(MainActivity.this, "hah", Toast.LENGTH_SHORT).show();
                       //创建一个线程
                       Message sdfMessage=new Message();
                       sdfMessage.what=12 ;
                       murMyrunnable.mHandler.sendMessage(sdfMessage);
                   }

               });

                 

            }

        }).start();
	
		//er.setClickable(false);
	}
	
	
	class Myrunnable implements Runnable{




            //延迟两秒


        	 public Handler mHandler;

             public void run() {

                             Looper.prepare();

                             mHandler = new Handler() {

                                             public void handleMessage(Message msg) {

                                            	 Toast.makeText(MainActivity.this, "wewe"+msg.what, Toast.LENGTH_SHORT).show();
                                             }

                             };

                             Looper.loop();


        }

   
	}		
		
		
	}

 

2.使用AsyncTask

关于AsyncTask的使用网上已经有很多资料这里不再详述，只是简单介绍下用法，以及其内部与handler的关系。

 AsyncTask屏蔽了很多多线程的实现细节，很适合初学者使用，现在通过代码来介绍：

public class MainActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
	    final Handler mHandler=new Handler();
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		final MyButton er=(MyButton) findViewById(R.id.ddd);
		Log.v("onCreate",	 "onCreate");
		er.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v)｛MyAsyncTask myAsyncTask = new MyAsyncTask(MainActivity.this);
			      myAsyncTask.execute(20);
				
			}
		});


}
/*
 * integer：启动任务执行的输入参数，integer：后台任务完成的进度值的类型；String：后台执行任务完成后返回结果的类型
 * 这三个参数可以根据需要进行设定
 */
class MyAsyncTask extends AsyncTask<Integer, Integer, String>{
	
	ProgressDialog pDialog;
	Context mContext;
	public  MyAsyncTask( Context mContext){
		this.mContext=mContext;
	}

     //核心函数，可以理解为在子线程中执行
	@Override
	protected String doInBackground(final Integer... params) {
		
	
			 Integer percent=params[0];
   
				 while (percent<101) {
					 percent++;
					 publishProgress(percent);
					Log.v("percent", percent+"");
				}
				
				  

		return null;
	}
	/*
	 * 上个函数的结果作为参数，传给result形参，函数内部执行更新UId的更新操作，可以理解为在UI线程中执行
	 * @see android.os.AsyncTask#onPostExecute(java.lang.Object)
	 */
	@Override
	protected void onPostExecute(String result) {
		// TODO Auto-generated method stub
		super.onPostExecute(result);
	}	
	/*
	 * 在执行第一个函数之前执行，做一些准备工作，可以理解为在UI线程中执行
	 * @see android.os.AsyncTask#onPreExecute()
	 */
	@Override
	protected void onPreExecute() {
		
		//这里的准备工作是显示进度条
		pDialog=new ProgressDialog(mContext);
		pDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
		pDialog.show();
		
	}
	/*
	 * 可以在第一个函数中调用，更新新进度注意是可以，无需求可以不用使用。
	 * @see android.os.AsyncTask#onProgressUpdate(java.lang.Object[])
	 */
	@Override
	protected void onProgressUpdate(Integer... values) {
		
		pDialog.setProgress(values[0]);
	}
}
 

 AsyncTask内部实际上new了一个Handler。如下图：

再来看下InternalHandler的定义：

    private static class InternalHandler extends Handler {
        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult result = (AsyncTaskResult) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // There is only one result
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

显而易见，InternalHandler继承自Handler。

重点不是Handler在哪个类中new的，而是只要是new了Handler，就可以通过Handler向创建Handler的那个线程中发送Message消息。

这就是为什么使用AsyncTask时必须在UI线程中创建的原因。

大概的原来不再赘述，原理与上一部分Handler的运行机制大同小异。

3.Activity.runOnUiThread(Runnbale)

在子线程中调用Activity.runOnUiThread(Runnbale)方法，在传过来的Runnbale参数的run方法里更新主线程UI。具体可以参考以下代码：

public class MainActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		final MyButton er=(MyButton) findViewById(R.id.ddd);		

        //创建一个线程

        new Thread(new Runnable() {

 

            @Override

            public void run() {

 

                //延迟两秒

                try {

                    Thread.sleep( 5000 );

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

 

                runOnUiThread(new Runnable() {

                    @Override

                    public void run() {
                    	er.setText("变了");
                        Toast.makeText(MainActivity.this, "hah", Toast.LENGTH_SHORT).show();

                    }

                });

 

            }

        }).start();
	
		//er.setClickable(false);
	}
}

注意为了保证线程安全，要更改的UI控件必须是final的。为什么说Activity.runOnUiThread(Runnbale)内部是用Handler实现的呢？我们来看下runOnUiThread(Runnbale)的源码就清楚了。

    /**
     * Runs the specified action on the UI thread. If the current thread is the UI
     * thread, then the action is executed immediately. If the current thread is
     * not the UI thread, the action is posted to the event queue of the UI thread.
     *
     * @param action the action to run on the UI thread
     */
    public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {
            mHandler.post(action);
        } else {
            action.run();
        }
    }

看到mHandler对象了吗？我们来看下它的定义：

    final Handler mHandler = new Handler();

所以是不是很清楚了。不管Handler在哪个类中new出来，用Handler传值都会传到创建Handler的那个线程中，重点的不是在哪个类中new，而是Handler在哪个线程中。

4.View.post(Runnbale)

其实这个的用法和上边讲的很类似。在子线程中调用某个view的post(Runnbale)方法，在传过来的Runnbale参数的run方法里更新主线程UI。具体可以参考以下代码：

        new Thread(new Runnable() {

 

            @Override

            public void run() {

 

                //延迟两秒


                try {

                    Thread.sleep( 5000 );

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

 

                er.post(new Runnable() {

                    @Override

                    public void run() {
                    	er.setText("变了");
                        Toast.makeText(MainActivity.this, "hah", Toast.LENGTH_SHORT).show();

                    }

                });
             
                 
                 

            }

        }).start();

为什么可以这样调用，因为View中也定义了Handler的对象,看下边的源码：

 

找到mHandler的定义：

5.View.postDelayed(Runnalbe,long)

和上边的类似，无非是延迟一些毫秒数来执行Runnable里面的方法，如View.postDelayed(Runnalbe,2000)是延迟2秒执行。

 

欢迎大家留言讨论。

后边将介绍造成安卓动态化的第三种因素：进程之间的通讯。