對於從事過J2ME開發的程序員來說Thread比較簡單,直接匿名創建重寫run方法,調用start方法執行即可。或者從Runnable接口繼承,但對於Android平臺來說UI控件都沒有設計成爲線程安全類型,所以需要引入一些同步的機制來使其刷新,這點Google在設計Android時倒是參考了下Win32的消息處理機制。
1. 對於線程中的刷新一個View爲基類的界面,可以使用postInvalidate()方法在線程中來處理,其中還提供了一些重寫方法比如postInvalidate(int left,int top,int right,int bottom) 來刷新一個矩形區域,以及延時執行,比如postInvalidateDelayed(long delayMilliseconds)或postInvalidateDelayed(long delayMilliseconds,int left,int top,int right,int bottom) 方法,其中第一個參數爲毫秒
2. 當然推薦的方法是通過一個Handler來處理這些,可以在一個線程的run方法中調用handler對象的 postMessage或sendMessage方法來實現,Android程序內部維護着一個消息隊列,會輪訓處理這些,如果你是Win32程序員可以很好理解這些消息處理,不過相對於Android來說沒有提供 PreTranslateMessage這些干涉內部的方法。
3. Looper又是什麼呢? ,其實Android中每一個Thread都跟着一個Looper,Looper可以幫助Thread維護一個消息隊列,但是Looper和Handler沒有什麼關係,我們從開源的代碼可以看到Android還提供了一個Thread繼承類HanderThread可以幫助我們處理,在HandlerThread對象中可以通過getLooper方法獲取一個Looper對象控制句柄,我們可以將其這個Looper對象映射到一個Handler中去來實現一個線程同步機制,Looper對象的執行需要初始化Looper.prepare方法就是昨天我們看到的問題,同時推出時還要釋放資源,使用Looper.release方法。
4.Message 在Android是什麼呢? 對於Android中Handler可以傳遞一些內容,通過Bundle對象可以封裝String、Integer以及Blob二進制對象,我們通過在線程中使用Handler對象的sendEmptyMessage或sendMessage方法來傳遞一個Bundle對象到Handler處理器。對於Handler類提供了重寫方法handleMessage(Message msg) 來判斷,通過msg.what來區分每條信息。將Bundle解包來實現Handler類更新UI線程中的內容實現控件的刷新操作。相關的Handler對象有關消息發送sendXXXX相關方法如下,同時還有postXXXX相關方法,這些和Win32中的道理基本一致,一個爲發送後直接返回,一個爲處理後才返回 .
5. java.util.concurrent對象分析,對於過去從事Java開發的程序員不會對Concurrent對象感到陌生吧,他是JDK 1.5以後新增的重要特性作爲掌上設備,我們不提倡使用該類,考慮到Android爲我們已經設計好的Task機制,這裏不做過多的贅述,相關原因參考下面的介紹:
6. 在Android中還提供了一種有別於線程的處理方式,就是Task以及AsyncTask,從開源代碼中可以看到是針對Concurrent的封裝,開發人員可以方便的處理這些異步任務。
- public class MyHandlerActivity extends Activity {
- Button button;
- MyHandler myHandler;
- protected void onCreate(Bundle savedInstanceState) {
- super。onCreate(savedInstanceState);
- setContentView(R。layout。handlertest);
- button = (Button) findViewById(R。id。button);
- myHandler = new MyHandler();
- // 當創建一個新的Handler實例時, 它會綁定到當前線程和消息的隊列中,開始分發數據
- // Handler有兩個作用, (1) : 定時執行Message和Runnalbe 對象
- // (2): 讓一個動作,在不同的線程中執行。
- // 它安排消息,用以下方法
- // post(Runnable)
- // postAtTime(Runnable,long)
- // postDelayed(Runnable,long)
- // sendEmptyMessage(int)
- // sendMessage(Message);
- // sendMessageAtTime(Message,long)
- // sendMessageDelayed(Message,long)
- // 以上方法以 post開頭的允許你處理Runnable對象
- //sendMessage()允許你處理Message對象(Message裏可以包含數據,)
- MyThread m = new MyThread();
- new Thread(m)。start();
- }
- /**
- * 接受消息,處理消息 ,此Handler會與當前主線程一塊運行
- * */
- class MyHandler extends Handler {
- public MyHandler() {
- }
- public MyHandler(Looper L) {
- super(L);
- }
- // 子類必須重寫此方法,接受數據
- @Override
- public void handleMessage(Message msg) {
- // TODO Auto-generated method stub
- Log。d("MyHandler", "handleMessage。。。。。。");
- super。handleMessage(msg);
- // 此處可以更新UI
- Bundle b = msg。getData();
- String color = b。getString("color");
- MyHandlerActivity。this。button。append(color);
- }
- }
- class MyThread implements Runnable {
- public void run() {
- try {
- Thread。sleep(10000);
- } catch (InterruptedException e) {
- // TODO Auto-generated catch block
- e。printStackTrace();
- }
- Log。d("thread。。。。。。。", "mThread。。。。。。。。");
- Message msg = new Message();
- Bundle b = new Bundle();// 存放數據
- b。putString("color", "我的");
- msg。setData(b);
- MyHandlerActivity。this。myHandler。sendMessage(msg); // 向Handler發送消息,更新UI
- }
- }
- }
這個例子是最簡單的介紹handler使用的,是將handler綁定到它所建立的線程中.
本次實驗完成的功能是:單擊Start按鈕,程序會開始啓動線程,並且線程程序完成後延時1s會繼續啓動該線程,每次線程的run函數中完成對界面輸出nUpdateThread...文字,不停的運行下去,當單擊End按鈕時,該線程就會停止,如果繼續單擊Start,則文字又開始輸出了。
軟件界面如下:
實驗主要部分代碼和註釋:
MainActivity.java:
package com.example.handler1;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private TextView text_view = null;
private Button start = null;
private Button end = null;
//使用handler時首先要創建一個handler
Handler handler = new Handler();
//要用handler來處理多線程可以使用runnable接口,這裏先定義該接口
//線程中運行該接口的run函數
Runnable update_thread = new Runnable()
{
public void run()
{
//線程每次執行時輸出"UpdateThread..."文字,且自動換行
//textview的append功能和Qt中的append類似,不會覆蓋前面
//的內容,只是Qt中的append默認是自動換行模式
text_view.append("\nUpdateThread...");
//延時1s後又將線程加入到線程隊列中
handler.postDelayed(update_thread, 1000);
}
};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
text_view = (TextView)findViewById(R.id.text_view);
start = (Button)findViewById(R.id.start);
start.setOnClickListener(new StartClickListener());
end = (Button)findViewById(R.id.end);
end.setOnClickListener(new EndClickListener());
}
private class StartClickListener implements OnClickListener
{
public void onClick(View v) {
// TODO Auto-generated method stub
//將線程接口立刻送到線程隊列中
handler.post(update_thread);
}
}
private class EndClickListener implements OnClickListener
{
public void onClick(View v) {
// TODO Auto-generated method stub
//將接口從線程隊列中移除
handler.removeCallbacks(update_thread);
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
activity_main.xml:
<LinearLayout 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:orientation="vertical" >
<TextView
android:id="@+id/text_view"
android:layout_width="fill_parent"
android:layout_height="200dip"
android:text="@string/hello_world"
tools:context=".MainActivity" />
<Button
android:id="@+id/start"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/start"
/>
<Button
android:id="@+id/end"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/end"
/>
</LinearLayout>
Handler使用例2
這個例子比剛纔那個例子稍微複雜些。因爲這個例子中用到了handler的消息隊列機制,即通過handler中一個線程向消息隊列中用sendMessage方法發送消息,發送的消息當然可以用來傳遞參數。在handler中用handleMessage來處理消息,處理方法是獲得消息隊列中的消息參數,用這些參數來完成另外一些功能。
本實驗實現的是當開始按鈕按下時,會啓動一個線程,並綁定到handler中,該線程發送帶有參數的message到handler的消息隊列中,消息隊列的另一端獲取該消息,並且用該消息的參數來更新進度條。
軟件打開後:
單擊Start按鈕後,更新的進度條結果如下(怎麼感覺4.1版本android進度條那麼小呢?不懂該怎麼設置):
實驗主要部分代碼和註釋:
MainActivity.java:
package com.example.handler2;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ProgressBar;
public class MainActivity extends Activity {
private ProgressBar progress_bar = null;
private Button start = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
progress_bar = (ProgressBar)findViewById(R.id.progress_bar);
start = (Button)findViewById(R.id.start);
start.setOnClickListener(new StartOnClickListenr());
}
private class StartOnClickListenr implements OnClickListener
{
public void onClick(View v) {
// TODO Auto-generated method stub
//讓進度條顯示出來
progress_bar.setVisibility(View.VISIBLE);
//將線程加入到handler的線程隊列中
update_progress_bar.post(update_thread);
}
}
//創建一個handler,內部完成處理消息方法
Handler update_progress_bar = new Handler()
{
@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
//super.handleMessage(msg);
//顯示進度條
progress_bar.setProgress(msg.arg1);
//重新把進程加入到進程隊列中
update_progress_bar.post(update_thread);
}
};//不加這個分號則不能自動添加代碼
Runnable update_thread = new Runnable()
{
int i = 0;
public void run() {
// TODO Auto-generated method stub
i += 10;
//首先獲得一個消息結構
Message msg = update_progress_bar.obtainMessage();
//給消息結構的arg1參數賦值
msg.arg1 = i;
//延時1s,java中的try+catch用來排錯處理
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
}
//把消息發送到消息隊列中
update_progress_bar.sendMessage(msg);
if(i == 100)
//把線程從線程隊列中移除
update_progress_bar.removeCallbacks(update_thread);
}
};
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
activity_main.xml:
<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" >
<Button
android:id="@+id/start"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:text="@string/start"
/>
<ProgressBar
android:id="@+id/progress_bar"
android:layout_width="fill_parent"
android:layout_height="100dip"
android:layout_alignParentTop="true"
style="?android:attr/progressBarStyleHorizontal"
android:visibility="gone"
/>
</RelativeLayout>
Handler使用例3
上面2個例子表面上看handler使用了post方法啓動了runnbale,其實啓動的線程和activity主線程是同一個線程,因爲它只是運行了線程的run方法,而不是start方法。Mars老師實驗3的目的是爲了驗證僅使用handler的post方法是否處於同一個線程。
該實驗在主activtiy的onCreate函數中打印了2條關於本線程的信息,然後創建一個handler併爲它綁定一個線程,在線程的run方法中也打印了線程的信息,觀察2者的信息是否一樣。
結果如下:
說明這2個線程確實是同一線程,並且可以看出主界面中的文字大概過了10s才顯示出來,因爲語句setContentView(R.layout.activity_main);放在了handler的post啓動語句後面,而handler綁定的線程中又延時了10s,所以同時也證明了只有是同一個線程纔會出現這種情況。
程序主要代碼和註釋如下:
MainActivity.java:
package com.example.handler3;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.Menu;
public class MainActivity extends Activity {
//新建一個handler
private Handler handler = new Handler();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//將runnable加載到handler的線程隊列中去
// handler.post(r);
Thread t = new Thread(r);
t.start();
setContentView(R.layout.activity_main);
//打印activtiy線程信息
System.out.println("activity_id---->"+Thread.currentThread().getId());
System.out.println("activity_name---->"+Thread.currentThread().getName());
}
Runnable r = new Runnable()
{
public void run() {
// TODO Auto-generated method stub
//打印新建線程信息
System.out.println("handler_id---->"+Thread.currentThread().getId());
System.out.println("handler_name---->"+Thread.currentThread().getName());
//延時10s,爲了觀察主界面中內容出現的時間
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
}
}
};
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
如果把語句:
handler.post(r);
換成:
Thread t = new Thread(r);
t.start();
其它的不變,則程序運行時主界面內容立刻就顯示出來了,且系統輸出如下:
這2者都說明這樣綁定的線程與它所在的activity線程就不是同一個線程了。
Handler使用例4
這個例子將學會怎樣不使用runnable來啓動一個線程,而是用HandlerThread的looper來構造一個handler,然後該handler自己獲得消息,並傳遞數據,然後又自己處理消息,當然這是在另一個線程中完成的。
消息結構中傳遞簡單的整型可以採用它的參數arg1和arg2,或者傳遞一些小的其它數據,可以用它的object,該object可以是任意的對象。當需要傳送比較大的數據是,可以使用消息的setData方法,該方法需要傳遞一個Bundle的參數。Bundle中存放的是鍵值對的map,只是它的鍵值類型和數據類型比較固定而已。
程序主要代碼和註釋如下:
MainActivity.java:
package com.example.handler4;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
System.out.println("activity_ID---->"+Thread.currentThread().getId());
//新建一個HanderThread對象,該對象實現了用Looper來處理消息隊列的功能
HandlerThread handler_thread = new HandlerThread("handler_thread");
handler_thread.start();
//MyHandler類是自己繼承的一個類,這裏採用hand_thread的Looper來初始化它
MyHandler my_handler = new MyHandler(handler_thread.getLooper());
//獲得一個消息msg
Message msg = my_handler.obtainMessage();
//採用Bundle保存數據,Bundle中存放的是鍵值對的map,只是它的鍵值類型和數據類型比較固定而已
Bundle b = new Bundle();
b.putString("whether", "晴天");
b.putInt("temperature", 34);
msg.setData(b);
//將msg發送到自己的handler中,這裏指的是my_handler,調用該handler的HandleMessage方法來處理該mug
msg.sendToTarget();
}
class MyHandler extends Handler
{
//空的構造函數
public MyHandler()
{}
//以Looper類型參數傳遞的函數,Looper爲消息泵,不斷循環的從消息隊列中得到消息並處理,因此
//每個消息隊列都有一個Looper,因爲Looper是已經封裝好了的消息隊列和消息循環的類
public MyHandler(Looper looper)
{
//調用父類的構造函數
super(looper);
}
@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
System.out.println("Handler_ID---->"+Thread.currentThread().getId());
System.out.println("Handler_Name---->"+Thread.currentThread().getId());
//將消息中的bundle數據取出來
Bundle b = msg.getData();
String whether = b.getString("whether");
int temperature = b.getInt("temperature");
System.out.println("whether= "+whether+" ,temperature= "+temperature);
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
總結:
Android中的handler可以用來完成異步的消息出來,即發送消息和接收消息相互獨立,可以同時運行。在例1和例2中,實際上handler中使用的線程是與它所在的activity處於同一個主線程,因爲handler中調用的runnable接口是直接運行該接口的run函數的,而不是start函數。例3專門比較了這2中情況。例4學會使用怎樣在新線程中處理消息的方法。