androidのhandler

16661 ワード
もうすぐ1年间ブログを更新していないで、この1年は少し奔走することに疲れて、详しくQ空间の中で更に书くようにしましょう.Androidに転身したので、新しい学习の过程を始めました.今回のブログの新たな成长を期待しています.
この文書はHandlerについてです.Handlerは主にサブスレッドから送信されたデータを受け取り,このデータをメインスレッドに合わせてUIを更新する.アプリケーションが起動すると、Androidはまずメインスレッド(つまりUIスレッド)を開きます.メインスレッドは管理インタフェースのUIコントロールであり、イベントの配布を行います.例えば、Buttonをクリックすると、AndroidはButtonにイベントを配布し、操作に応答します.この時点で時間のかかる操作が必要な場合、例えば、ネットワークでデータを読み取るか、ローカルの大きなファイルを読み取る場合は、これらの操作をメインスレッドに置くことはできません.メインスレッドに置くと、インタフェースに偽死現象が発生し、5秒も完成していない場合は、Androidシステムのエラーメッセージ「強制閉鎖」が表示されます.
この場合、サブスレッドはUIの更新に関連しているため、Androidプライマリスレッドはスレッドが安全ではありません.つまり、UIの更新はプライマリスレッドでしか更新できません.サブスレッドでの操作は危険です.この時、Handlerはこの複雑な問題を解決するために現れた.Handlerは、メインスレッド(UIスレッド)で動作し、サブスレッドとMessageオブジェクトを介してデータを伝達することができる.このとき、Handlerは、サブスレッドからの(サブスレッドはsedMessage()メソッドで伝達される)Messageオブジェクト(データを含む)を受け取り、これらのメッセージをメインスレッドキューに入れ、メインスレッドに合わせてUIを更新する.
Handlerのいくつかの特徴:HandlerはMessageオブジェクトとRunnableオブジェクトをプライマリ・スレッドに配布することができ、各Handlerインスタンスは、作成されたスレッド(一般的にプライマリ・スレッドに存在する)にバインドされ、(1):メッセージのスケジュールまたはRunnableがプライマリ・スレッドのどこかで実行され、(2)アクションが異なるスレッドで実行されるようにスケジュールされます.
Handlerでメッセージを配信するにはpost(Runnable)メソッドとsendMessage(Message)メソッドがよく使用されます.
まずsendMessageの例です.
       

  
  
  
  
    
   
   
   
   
  1. 　　public class HandlerActivity extends Activity {  
    2. 
   
   
   
   
  2.  
    3. 
   
   
   
   
  3. 　　private TextView textView;  
    4. 
   
   
   
   
  4.  
    5. 
   
   
   
   
  5. 　　private MyHandler myHandler;  
    6. 
   
   
   
   
  6.  
    7. 
   
   
   
   
  7. 　　private Button button;  
    8. 
   
   
   
   
  8.  
    9. 
   
   
   
   
  9. 　　private ProgressBar progressBar;  
    10. 
   
   
   
   
  10.  
    11. 
   
   
   
   
  11. 　　private MyThread m=new MyThread();  
    12. 
   
   
   
   
  12.  
    13. 
   
   
   
   
  13. 　　/** Called when the activity is first created. */ 
    14. 
   
   
   
   
  14.  
    15. 
   
   
   
   
  15. 　　@Override 
    16. 
   
   
   
   
  16.  
    17. 
   
   
   
   
  17. 　　public void onCreate(Bundle savedInstanceState) {  
    18. 
   
   
   
   
  18.  
    19. 
   
   
   
   
  19. 　　super.onCreate(savedInstanceState);  
    20. 
   
   
   
   
  20.  
    21. 
   
   
   
   
  21. 　　setContentView(R.layout.main);  
    22. 
   
   
   
   
  22.  
    23. 
   
   
   
   
  23. 　　textView=(TextView)findViewById(R.id.text);  
    24. 
   
   
   
   
  24.  
    25. 
   
   
   
   
  25. 　　button=(Button)findViewById(R.id.startButton);  
    26. 
   
   
   
   
  26.  
    27. 
   
   
   
   
  27. 　　progressBar=(ProgressBar)findViewById(R.id.bar);  
    28. 
   
   
   
   
  28.  
    29. 
   
   
   
   
  29. 　　progressBar.setMax(100);  
    30. 
   
   
   
   
  30.  
    31. 
   
   
   
   
  31. 　　button.setOnClickListener(new View.OnClickListener() {  
    32. 
   
   
   
   
  32.  
    33. 
   
   
   
   
  33. 　　@Override 
    34. 
   
   
   
   
  34.  
    35. 
   
   
   
   
  35. 　　public void onClick(View arg0) {  
    36. 
   
   
   
   
  36.  
    37. 
   
   
   
   
  37. 　　myHandler=new MyHandler();  
    38. 
   
   
   
   
  38.  
    39. 
   
   
   
   
  39. 　　new Thread(m).start();  
    40. 
   
   
   
   
  40.  
    41. 
   
   
   
   
  41. 　　System.out.println("onCreate--The Thread is: "+Thread.currentThread().getId());  
    42. 
   
   
   
   
  42.  
    43. 
   
   
   
   
  43. 　　}  
    44. 
   
   
   
   
  44.  
    45. 
   
   
   
   
  45. 　　});  
    46. 
   
   
   
   
  46.  
    47. 
   
   
   
   
  47. 　　}  
    48. 
   
   
   
   
  48.  
    49. 
   
   
   
   
  49. 　　//  UI     ，          UI    
    50. 
   
   
   
   
  50.  
    51. 
   
   
   
   
  51. 　　class MyHandler extends Handler{//  Handler  ，    handleMessage    
    52. 
   
   
   
   
  52.  
    53. 
   
   
   
   
  53. 　　public MyHandler(){  
    54. 
   
   
   
   
  54.  
    55. 
   
   
   
   
  55. 　　}  
    56. 
   
   
   
   
  56.  
    57. 
   
   
   
   
  57. 　　public MyHandler(Looper l){  
    58. 
   
   
   
   
  58.  
    59. 
   
   
   
   
  59. 　　super(l);  
    60. 
   
   
   
   
  60.  
    61. 
   
   
   
   
  61. 　　}  
    62. 
   
   
   
   
  62.  
    63. 
   
   
   
   
  63. 　　@Override 
    64. 
   
   
   
   
  64.  
    65. 
   
   
   
   
  65. 　　public void handleMessage(Message msg) {//        ，              ，       
    66. 
   
   
   
   
  66.  
    67. 
   
   
   
   
  67. 　　System.out.println("Handler--The ThreadId is: "+Thread.currentThread().getId());  
    68. 
   
   
   
   
  68.  
    69. 
   
   
   
   
  69. 　　super.handleMessage(msg);  
    70. 
   
   
   
   
  70.  
    71. 
   
   
   
   
  71. 　　Bundle b=msg.getData();  
    72. 
   
   
   
   
  72.  
    73. 
   
   
   
   
  73. 　　String textStr0=textView.getText().toString();  
    74. 
   
   
   
   
  74.  
    75. 
   
   
   
   
  75. 　　String textStr1=b.getString("textStr");  
    76. 
   
   
   
   
  76.  
    77. 
   
   
   
   
  77. 　　HandlerActivity.this.textView.setText(textStr0+" "+textStr1);//  TextView     
    78. 
   
   
   
   
  78.  
    79. 
   
   
   
   
  79. 　　int barValue=b.getInt("barValue");HandlerActivity.this.progressBar.setProgress(barValue);//           
    80. 
   
   
   
   
  80.  
    81. 
   
   
   
   
  81. 　　}  
    82. 
   
   
   
   
  82.  
    83. 
   
   
   
   
  83. 　　}  
    84. 
   
   
   
   
  84.  
    85. 
   
   
   
   
  85. 　　//                
    86. 
   
   
   
   
  86.  
    87. 
   
   
   
   
  87. 　　class MyThread implements Runnable{  
    88. 
   
   
   
   
  88.  
    89. 
   
   
   
   
  89. 　　int i=1;  
    90. 
   
   
   
   
  90.  
    91. 
   
   
   
   
  91. 　　@Override 
    92. 
   
   
   
   
  92.  
    93. 
   
   
   
   
  93. 　　public void run() {  
    94. 
   
   
   
   
  94.  
    95. 
   
   
   
   
  95. 　　while(i<11){  
    96. 
   
   
   
   
  96.  
    97. 
   
   
   
   
  97. 　　System.out.println("Thread--The ThreadId is: "+Thread.currentThread().getId());  
    98. 
   
   
   
   
  98.  
    99. 
   
   
   
   
  99. 　　try {  
    100. 
   
   
   
   
  100.  
    101. 
   
   
   
   
  101. 　　Thread.sleep(1000);  
    102. 
   
   
   
   
  102.  
    103. 
   
   
   
   
  103. 　　} catch (InterruptedException e) {  
    104. 
   
   
   
   
  104.  
    105. 
   
   
   
   
  105. 　　e.printStackTrace();  
    106. 
   
   
   
   
  106.  
    107. 
   
   
   
   
  107. 　　}  
    108. 
   
   
   
   
  108.  
    109. 
   
   
   
   
  109. 　　Message msg=new Message();  
    110. 
   
   
   
   
  110.  
    111. 
   
   
   
   
  111. 　　Bundle b=new Bundle();  
    112. 
   
   
   
   
  112.  
    113. 
   
   
   
   
  113. 　　b.putString("textStr", "    "+i+" ");  
    114. 
   
   
   
   
  114.  
    115. 
   
   
   
   
  115. 　　b.putInt("barValue", i*10);  
    116. 
   
   
   
   
  116.  
    117. 
   
   
   
   
  117. 　　i++;  
    118. 
   
   
   
   
  118.  
    119. 
   
   
   
   
  119. 　　msg.setData(b);  
    120. 
   
   
   
   
  120.  
    121. 
   
   
   
   
  121. 　　HandlerActivity.this.myHandler.sendMessage(msg);//  sendMessage Handler    UI     
    122. 
   
   
   
   
  122.  
    123. 
   
   
   
   
  123. 　　}  
    124. 
   
   
   
   
  124.  
    125. 
   
   
   
   
  125. 　　}  
    126. 
   
   
   
   
  126.  
    127. 
   
   
   
   
  127. 　　}  
    128. 
   
   
   
   
  128.  
    129. 
   
   
   
   
  129. 　　} 
    130.

 
簡単に言えば、ActivityのonCreateメソッドでスレッドを起動し、このスレッドのrunメソッドでMessageオブジェクトを使用してHandlerのsendMessageメソッドを使用してキューに送信し、最後にActivityでnewのHandlerの内部クラスでhandMessageメソッドを実現し、このメソッドを使用してキュー内のMessageオブジェクトを取り出して非同期操作を実現します.
次にpostの例ですが、ここで少しお話しして、そのままnew Handler()を使います.post(Runnable)のような書き方は,新規にスレッドを開くことはなく,つまり依然としてマスタスレッドで実行され,startメソッドではなくスレッドを単純に呼び出したrunメソッドに相当する.これはandroidのバグだと言われていますが、ソリューションはこのように使用されています.
  

  
  
  
  
    
   
   
   
   
  1. HandlerThread handlerThread = new HandlerThread("myHandlerThread");  
    2. 
   
   
   
   
  2. handlerThread.start();  
    3. 
   
   
   
   
  3. handler = new Handler(handlerThread.getLooper()); 
    4.

完全なpostの例を見てみましょう
  

  
  
  
  
    
   
   
   
   
  1. public class MyThread extends Activity {    
    2. 
   
   
   
   
  2.     private Handler handler = null;    
    3. 
   
   
   
   
  3.     @Override    
    4. 
   
   
   
   
  4.     public void onCreate(Bundle savedInstanceState) {    
    5. 
   
   
   
   
  5.         super.onCreate(savedInstanceState);    
    6. 
   
   
   
   
  6.         HandlerThread handlerThread = new HandlerThread("myHandlerThread");    
    7. 
   
   
   
   
  7.         handlerThread.start();    
    8. 
   
   
   
   
  8.         handler = new Handler(handlerThread.getLooper());    
    9. 
   
   
   
   
  9.         handler.post(new MyRunnable());    
    10. 
   
   
   
   
  10.         System.out.println("Oncreate---The Thread id is :"    
    11. 
   
   
   
   
  11.                 + Thread.currentThread().getId());    
    12. 
   
   
   
   
  12.         setContentView(R.layout.main);    
    13. 
   
   
   
   
  13.     }    
    14. 
   
   
   
   
  14.     private class MyRunnable implements Runnable {    
    15. 
   
   
   
   
  15.         public void run() {    
    16. 
   
   
   
   
  16.             System.out.println("Runnable---The Thread is running");    
    17. 
   
   
   
   
  17.             System.out.println("Runnable---The Thread id is :"    
    18. 
   
   
   
   
  18.                     + Thread.currentThread().getId());    
    19. 
   
   
   
   
  19.             try {    
    20. 
   
   
   
   
  20.                 Thread.sleep(6000);    
    21. 
   
   
   
   
  21.             } catch (InterruptedException e) {    
    22. 
   
   
   
   
  22.                 // TODO Auto-generated catch block    
    23. 
   
   
   
   
  23.                 e.printStackTrace();    
    24. 
   
   
   
   
  24.             }    
    25. 
   
   
   
   
  25.         }    
    26. 
   
   
   
   
  26.     }    
    27. 
   
   
   
   
  27. }   
    28.

このdemoではHandlerThreadが用いられ,HandlerThreadオブジェクトでgetLooper法によりLooperオブジェクト制御ハンドルを取得でき,このLooperオブジェクトをHandlerにマッピングしてスレッド同期機構を実現できる.そこで以下の結果が得られた.1:コンソールの出力:Oncreate---The Thread id is:1 Runnable---The Thread is running Runnable---The Thread id is:10 2:プログラムが起動すると、すぐにmainが表示されます.xmlの内容.これによりマルチスレッドの結果が得られる.
ITridentSpout、FirstN(TopNを取る)実装、ストリームマージ、join
group having