• Handler的交互场景

    我们在开发中经常用到的在子线程中执行耗时任务，然后通过Handler到主线程中更新UI。我们对它都很熟悉，今天再来复习一下这个Handler。下面几种方式是今天要复习的

     （1）单向的子线程与子线程交互：即由一个子线程向另一个子线程发送消息；

    需要先创建一个新的子线程，然后在子线程内创建Handler,来接收另一个子线程发来的消息。在子线程中创建Handler必须要先获取Looper，否则程序则会崩溃，并且会报错误：Can't create handler inside thread that has not called Looper.prepare()。Handler消息机制源码详解参考这篇文章：https://www.jianshu.com/p/750e3706c467

    1.     /*
    2.       （1）子线程与子线程交互（单向）。
    3.        创建一个新的子线程
    4.      */
    5.     class MyThread1 extends Thread{
    6.         public Handler mHandler1;
    7.  
    8.         @Override
    9.         public void run() {
    10.             super.run();
    11.             //1.实例化当前线程的Looper,每个线程只能有一个Looper实例。
    12.             Looper.prepare();
    13.             //2.创建Handler
    14.             mHandler1 = new Handler(){
    15.                 @Override
    16.                 public void handleMessage(@NonNull Message msg) {
    17.                     super.handleMessage(msg);
    18.                     switch (msg.what){
    19.                         case 0:
    20.                             runOnUiThread(new Runnable() {
    21.                                 @Override
    22.                                 public void run() {
    23.                                     tv_receivedMsg.setText("（1）子线程中使用Handler向另一个子线程发消息（单向）");
    24.                                 }
    25.                             });
    26.                             break;
    27.                     }
    28.                 }
    29.             };
    30.             //3.开启Looper循环接收消息
    31.             Looper.loop();
    32.         }
    33.     }

    之后由一个线程向这个新线程发送消息

    1.     private MyThread1 myThread1;
    2.         
    3.         myThread1 = new MyThread1();
    4.         myThread1.start();
    5.  
    6.                 new Thread(){
    7.                     @Override
    8.                     public void run() {
    9.                         super.run();
    10.                         myThread1.mHandler1.sendEmptyMessage(0);
    11.                     }
    12.                 }.start();

    （2）两个子线程互发消息（双向）：需要创建两个线程并相互发送消息

    1.     /*
    2.       （2）两个子线程互发消息（双向）
    3.        即创建两个线程，并在一个线程发送消息到另一个线程处理
    4.      */
    5.     class MyThread21 extends Thread{
    6.         public Handler mHandler21;
    7.         @Override
    8.         public void run() {
    9.             super.run();
    10.             //1.实例化当前线程的Looper,每个线程只能有一个Looper实例。
    11.             Looper.prepare();
    12.             //2.创建Handler
    13.             mHandler21 = new Handler(){
    14.                 @Override
    15.                 public void handleMessage(@NonNull Message msg) {
    16.                     super.handleMessage(msg);
    17.                     switch (msg.what){
    18.                         case 20:
    19.                             runOnUiThread(new Runnable() {
    20.                                 @Override
    21.                                 public void run() {
    22.                                     tv_receivedMsg.setText("收到");
    23.                                     //收到消息，使用MyThread22的mHandler22向MyThread22发送消息
    24.                                     myThread22.mHandler22.sendEmptyMessage(22);
    25.                                 }
    26.                             });
    27.                             break;
    28.                         case 21:
    29.                             runOnUiThread(new Runnable() {
    30.                                 @Override
    31.                                 public void run() {
    32.                                     try {
    33.                                         Thread.sleep(2000);
    34.                                         //收到MyThread22发来的消息
    35.                                         tv_receivedMsg.setText("（2）两个子线程互发消息（双向）\n 线程1收到MyThread22发来的消息");
    36.                                     } catch (InterruptedException e) {
    37.                                         e.printStackTrace();
    38.                                     }
    39.                                 }
    40.                             });
    41.                             break;
    42.                     }
    43.                 }
    44.             };
    45.             //3.开启Looper循环接收消息
    46.             Looper.loop();
    47.         }
    48.     }
    49.  
    50.     class MyThread22 extends Thread{
    51.         public Handler mHandler22;
    52.         @Override
    53.         public void run() {
    54.             super.run();
    55.             //1.实例化当前线程的Looper,每个线程只能有一个Looper实例。
    56.             Looper.prepare();
    57.             //2.创建Handler
    58.             mHandler22 = new Handler(){
    59.                 @Override
    60.                 public void handleMessage(@NonNull Message msg) {
    61.                     super.handleMessage(msg);
    62.                     switch (msg.what){
    63.                         case 22:
    64.                             runOnUiThread(new Runnable() {
    65.                                 @Override
    66.                                 public void run() {
    67.                                     tv_receivedMsg.setText("（2）两个子线程互发消息（双向）\n 线程2收到myThread21发来的消息");
    68.                                     try {
    69.                                         Thread.sleep(2000);
    70.                                         //收到myThread21发来的消息，使用myThread21的mHandler21向myThread21发消息
    71.                                         myThread21.mHandler21.sendEmptyMessage(21);
    72.                                     } catch (InterruptedException e) {
    73.                                         e.printStackTrace();
    74.                                     }
    75.                                 }
    76.                             });
    77.                             break;
    78.                     }
    79.                 }
    80.             };
    81.             //3.开启Looper循环接收消息
    82.             Looper.loop();
    83.         }
    84.     }

    执行这两线程互相发送消息

    1.     private MyThread21 myThread21;
    2.     private MyThread22 myThread22;
    3.  
    4.     myThread21 = new MyThread21();
    5.     myThread22 = new MyThread22();
    6.     myThread21.start();
    7.     myThread22.start();
    8.  
    9.     myThread21.mHandler21.sendEmptyMessage(20);

    （3）主线程发送消息到子线程：先创建一个子线程

    1.     //（3）主线程发消息到子线程
    2.     class MyThread3 extends Thread{
    3.         public Handler mHandler3;
    4.  
    5.         @Override
    6.         public void run() {
    7.             super.run();
    8.             //1.实例化当前线程的Looper,每个线程只能有一个Looper实例。
    9.             Looper.prepare();
    10.             //2.创建Handler
    11.             mHandler3 = new Handler(){
    12.                 @Override
    13.                 public void handleMessage(@NonNull Message msg) {
    14.                     super.handleMessage(msg);
    15.                     switch (msg.what){
    16.                         case 0:
    17.                             runOnUiThread(new Runnable() {
    18.                                 @Override
    19.                                 public void run() {
    20.                                     tv_receivedMsg.setText("（3）子线程收到主线程发来的消息");
    21.                                 }
    22.                             });
    23.                             break;
    24.                     }
    25.                 }
    26.             };
    27.             //3.开启Looper循环接收消息
    28.             Looper.loop();
    29.         }
    30.     }

    然后由主线程向新建的子线程发送消息

    1.     private MyThread3 myThread3;
    2.  
    3.     myThread3 = new MyThread3();
    4.     myThread3.start();
    5.  
    6.     myThread3.mHandler3.sendEmptyMessage(0);

    （4）子线程发送消息主线程：这个也是我们平时最常用的

    1.                 //子线程发送消息主线程
    2.                 new Thread(new Runnable() {
    3.                     @Override
    4.                     public void run() {
    5.                         mHandler.sendEmptyMessage(4);
    6.                     }
    7.                 }).start();

    在主线程中创建Handler来接收消息

    1.     Handler mHandler = new Handler(){
    2.         @Override
    3.         public void handleMessage(@NonNull Message msg) {
    4.             super.handleMessage(msg);
    5.             switch (msg.what){
    6.                 case 4:
    7.                     tv_receivedMsg.setText("主线程收到子线程发来的消息");
    8.                     break;
    9.             }
    10.         }
    11.     };

    （5）附加一个handler.post的使用，可直接在run里面更新UI。Handler的sendMessage和post的区别可参考这篇文章：https://www.jianshu.com/p/43d6cd7b06f1

    1. mHandler.post(new Runnable() {
    2.     @Override
    3.     public void run() {
    4.         tv_receivedMsg.setText("handler.post通过实现Runnable接口,直接更新UI");
    5.     }
    6. });

    整个复习测试的完整源程序

    1. public class HandlerTestActivity extends AppCompatActivity {
    2.  
    3.     View viewStatus;
    4.     private Button btn_handler1,btn_handler2,btn_handler3,btn_handler4;
    5.     private Button btn_handlerPost;
    6.     private TextView tv_receivedMsg;
    7.  
    8.     private MyThread1 myThread1;
    9.  
    10.     private MyThread21 myThread21;
    11.     private MyThread22 myThread22;
    12.  
    13.     private MyThread3 myThread3;
    14.  
    15.     Handler mHandler = new Handler(){
    16.         @Override
    17.         public void handleMessage(@NonNull Message msg) {
    18.             super.handleMessage(msg);
    19.             switch (msg.what){
    20.                 case 4:
    21.                     tv_receivedMsg.setText("主线程收到子线程发来的消息");
    22.                     break;
    23.             }
    24.         }
    25.     };
    26.  
    27.     @Override
    28.     protected void onCreate(@Nullable Bundle savedInstanceState) {
    29.         super.onCreate(savedInstanceState);
    30.         setContentView(R.layout.activity_handler_test);
    31.         initView();
    32.         initData();
    33.         initListener();
    34.     }
    35.  
    36.     private void initView(){
    37.         if (Build.VERSION.SDK_INT >= 21) {
    38.             View decorView =getWindow().getDecorView();
    39.             int option = View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
    40.                     | View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
    41.             decorView.setSystemUiVisibility(option);
    42.             //这上面是颜色
    43.             getWindow().setStatusBarColor(Color.TRANSPARENT); //也可以设置成灰色透明的，比较符合Material Design的风格
    44.         }
    45.         viewStatus = findViewById(R.id.view_status);
    46.         ViewGroup.LayoutParams layoutParams = viewStatus.getLayoutParams();
    47.         layoutParams.height = getStatusBarHeight();
    48.  
    49.         btn_handler1 = findViewById(R.id.btn_handler1);
    50.         btn_handler2 = findViewById(R.id.btn_handler2);
    51.         btn_handler3 = findViewById(R.id.btn_handler3);
    52.         btn_handler4 = findViewById(R.id.btn_handler4);
    53.         btn_handlerPost = findViewById(R.id.btn_handlerPost);
    54.         tv_receivedMsg = findViewById(R.id.tv_receivedMsg);
    55.     }
    56.  
    57.     private void initData(){
    58.         /**
    59.          * （1）子线程与子线程交互（单向）。
    60.          */
    61.         myThread1 = new MyThread1();
    62.         myThread1.start();
    63.  
    64.         /**
    65.          * （2）两个子线程互发消息（双向）
    66.          */
    67.         myThread21 = new MyThread21();
    68.         myThread22 = new MyThread22();
    69.         myThread21.start();
    70.         myThread22.start();
    71.  
    72.         /**
    73.          * （3）主线程发送消息到子线程。
    74.          */
    75.         myThread3 = new MyThread3();
    76.         myThread3.start();
    77.     }
    78.  
    79.     private void initListener(){
    80.         //子线程中使用Handler向另一个子线程发消息（单向）
    81.         btn_handler1.setOnClickListener(new View.OnClickListener() {
    82.             @Override
    83.             public void onClick(View v) {
    84.                 new Thread(){
    85.                     @Override
    86.                     public void run() {
    87.                         super.run();
    88.                         myThread1.mHandler1.sendEmptyMessage(0);
    89.                     }
    90.                 }.start();
    91.             }
    92.         });
    93.  
    94.         btn_handler2.setOnClickListener(new View.OnClickListener() {
    95.             @Override
    96.             public void onClick(View v) {
    97.                 myThread21.mHandler21.sendEmptyMessage(20);
    98.             }
    99.         });
    100.  
    101.         btn_handler3.setOnClickListener(new View.OnClickListener() {
    102.             @Override
    103.             public void onClick(View v) {
    104.                 myThread3.mHandler3.sendEmptyMessage(0);
    105.             }
    106.         });
    107.  
    108.         btn_handler4.setOnClickListener(new View.OnClickListener() {
    109.             @Override
    110.             public void onClick(View v) {
    111.                 //子线程发送消息主线程
    112.                 new Thread(new Runnable() {
    113.                     @Override
    114.                     public void run() {
    115.                         mHandler.sendEmptyMessage(4);
    116.                     }
    117.                 }).start();
    118.             }
    119.         });
    120.  
    121.         //Handler.post的使用
    122.         btn_handlerPost.setOnClickListener(new View.OnClickListener() {
    123.             @Override
    124.             public void onClick(View v) {
    125.                 mHandler.post(new Runnable() {
    126.                     @Override
    127.                     public void run() {
    128.                         tv_receivedMsg.setText("handler.post通过实现Runnable接口,直接更新UI");
    129.                     }
    130.                 });
    131.             }
    132.         });
    133.     }
    134.  
    135.     /*
    136.       （1）子线程与子线程交互（单向）。
    137.        创建一个新的子线程
    138.      */
    139.     class MyThread1 extends Thread{
    140.         public Handler mHandler1;
    141.  
    142.         @Override
    143.         public void run() {
    144.             super.run();
    145.             //1.实例化当前线程的Looper,每个线程只能有一个Looper实例。
    146.             Looper.prepare();
    147.             //2.创建Handler
    148.             mHandler1 = new Handler(){
    149.                 @Override
    150.                 public void handleMessage(@NonNull Message msg) {
    151.                     super.handleMessage(msg);
    152.                     switch (msg.what){
    153.                         case 0:
    154.                             runOnUiThread(new Runnable() {
    155.                                 @Override
    156.                                 public void run() {
    157.                                     tv_receivedMsg.setText("（1）子线程中使用Handler向另一个子线程发消息（单向）");
    158.                                 }
    159.                             });
    160.                             break;
    161.                     }
    162.                 }
    163.             };
    164.             //3.开启Looper循环接收消息
    165.             Looper.loop();
    166.         }
    167.     }
    168.  
    169.     /*
    170.       （2）两个子线程互发消息（双向）
    171.        即创建两个线程，并在一个线程发送消息到另一个线程处理
    172.      */
    173.     class MyThread21 extends Thread{
    174.         public Handler mHandler21;
    175.         @Override
    176.         public void run() {
    177.             super.run();
    178.             //1.实例化当前线程的Looper,每个线程只能有一个Looper实例。
    179.             Looper.prepare();
    180.             //2.创建Handler
    181.             mHandler21 = new Handler(){
    182.                 @Override
    183.                 public void handleMessage(@NonNull Message msg) {
    184.                     super.handleMessage(msg);
    185.                     switch (msg.what){
    186.                         case 20:
    187.                             runOnUiThread(new Runnable() {
    188.                                 @Override
    189.                                 public void run() {
    190.                                     tv_receivedMsg.setText("收到");
    191.                                     //收到消息，使用MyThread22的mHandler22向MyThread22发送消息
    192.                                     myThread22.mHandler22.sendEmptyMessage(22);
    193.                                 }
    194.                             });
    195.                             break;
    196.                         case 21:
    197.                             runOnUiThread(new Runnable() {
    198.                                 @Override
    199.                                 public void run() {
    200.                                     try {
    201.                                         Thread.sleep(2000);
    202.                                         //收到MyThread22发来的消息
    203.                                         tv_receivedMsg.setText("（2）两个子线程互发消息（双向）\n 线程1收到MyThread22发来的消息");
    204.                                     } catch (InterruptedException e) {
    205.                                         e.printStackTrace();
    206.                                     }
    207.                                 }
    208.                             });
    209.                             break;
    210.                     }
    211.                 }
    212.             };
    213.             //3.开启Looper循环接收消息
    214.             Looper.loop();
    215.         }
    216.     }
    217.  
    218.     class MyThread22 extends Thread{
    219.         public Handler mHandler22;
    220.         @Override
    221.         public void run() {
    222.             super.run();
    223.             //1.实例化当前线程的Looper,每个线程只能有一个Looper实例。
    224.             Looper.prepare();
    225.             //2.创建Handler
    226.             mHandler22 = new Handler(){
    227.                 @Override
    228.                 public void handleMessage(@NonNull Message msg) {
    229.                     super.handleMessage(msg);
    230.                     switch (msg.what){
    231.                         case 22:
    232.                             runOnUiThread(new Runnable() {
    233.                                 @Override
    234.                                 public void run() {
    235.                                     tv_receivedMsg.setText("（2）两个子线程互发消息（双向）\n 线程2收到myThread21发来的消息");
    236.                                     try {
    237.                                         Thread.sleep(2000);
    238.                                         //收到myThread21发来的消息，使用myThread21的mHandler21向myThread21发消息
    239.                                         myThread21.mHandler21.sendEmptyMessage(21);
    240.                                     } catch (InterruptedException e) {
    241.                                         e.printStackTrace();
    242.                                     }
    243.                                 }
    244.                             });
    245.                             break;
    246.                     }
    247.                 }
    248.             };
    249.             //3.开启Looper循环接收消息
    250.             Looper.loop();
    251.         }
    252.     }
    253.  
    254.     //（3）主线程发消息到子线程
    255.     class MyThread3 extends Thread{
    256.         public Handler mHandler3;
    257.  
    258.         @Override
    259.         public void run() {
    260.             super.run();
    261.             //1.实例化当前线程的Looper,每个线程只能有一个Looper实例。
    262.             Looper.prepare();
    263.             //2.创建Handler
    264.             mHandler3 = new Handler(){
    265.                 @Override
    266.                 public void handleMessage(@NonNull Message msg) {
    267.                     super.handleMessage(msg);
    268.                     switch (msg.what){
    269.                         case 0:
    270.                             runOnUiThread(new Runnable() {
    271.                                 @Override
    272.                                 public void run() {
    273.                                     tv_receivedMsg.setText("（3）子线程收到主线程发来的消息");
    274.                                 }
    275.                             });
    276.                             break;
    277.                     }
    278.                 }
    279.             };
    280.             //3.开启Looper循环接收消息
    281.             Looper.loop();
    282.         }
    283.     }
    284.  
    285.     @Override
    286.     protected void onDestroy() {
    287.         if (null != myThread1.mHandler1){
    288.             myThread1.mHandler1.removeCallbacksAndMessages(null);
    289.         }
    290.         if (null != myThread21.mHandler21){
    291.             myThread21.mHandler21.removeCallbacksAndMessages(null);
    292.         }
    293.         if (null != myThread22.mHandler22){
    294.             myThread22.mHandler22.removeCallbacksAndMessages(null);
    295.         }
    296.         if (null != myThread3.mHandler3){
    297.             myThread3.mHandler3.removeCallbacksAndMessages(null);
    298.         }
    299.         super.onDestroy();
    300.     }
    301. }

    布局文件

    1. "1.0" encoding="utf-8"?>
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    3.     android:layout_width="match_parent"
    4.     android:layout_height="match_parent"
    5.     android:background="@color/background"
    6.     android:orientation="vertical">
    7.  
    8.     <View
    9.         android:id="@+id/view_status"
    10.         android:layout_width="match_parent"
    11.         android:layout_height="0dp"
    12.         android:background="#01012A" />
    13.  
    14.     <TextView
    15.         android:layout_width="match_parent"
    16.         android:layout_height="40dp"
    17.         android:text="Handler的交互场景"
    18.         android:background="@color/colorPrimary"
    19.         android:gravity="center"
    20.         android:textSize="18dp"
    21.         android:textColor="@color/white"/>
    22.  
    23.     <Button
    24.         android:id="@+id/btn_handler1"
    25.         android:layout_width="wrap_content"
    26.         android:layout_height="wrap_content"
    27.         android:text="（1）子线程与子线程交互（单向）"/>
    28.     <Button
    29.         android:id="@+id/btn_handler2"
    30.         android:layout_width="wrap_content"
    31.         android:layout_height="wrap_content"
    32.         android:layout_marginTop="10dp"
    33.         android:text="（2）两个子线程互发消息（双向）"/>
    34.  
    35.     <Button
    36.         android:id="@+id/btn_handler3"
    37.         android:layout_width="wrap_content"
    38.         android:layout_height="wrap_content"
    39.         android:layout_marginTop="10dp"
    40.         android:text="（3）主线程发送消息到子线程"/>
    41.  
    42.     <Button
    43.         android:id="@+id/btn_handler4"
    44.         android:layout_width="wrap_content"
    45.         android:layout_height="wrap_content"
    46.         android:layout_marginTop="10dp"
    47.         android:text="（4）子线程发送消息主线程"/>
    48.  
    49.     <Button
    50.         android:id="@+id/btn_handlerPost"
    51.         android:layout_width="wrap_content"
    52.         android:layout_height="wrap_content"
    53.         android:layout_marginTop="10dp"
    54.         android:text="（5）handlerPost方法"
    55.         android:textAllCaps="false"/>
    56.  
    57.     <TextView
    58.         android:layout_width="wrap_content"
    59.         android:layout_height="wrap_content"
    60.         android:text="接收消息："
    61.         android:textSize="18dp"
    62.         android:textColor="@color/white"/>
    63.     <TextView
    64.         android:id="@+id/tv_receivedMsg"
    65.         android:layout_width="wrap_content"
    66.         android:layout_height="wrap_content"
    67.         android:textSize="16dp"
    68.         android:textColor="@color/blueP"/>
    69.  
    70. LinearLayout>

  • 相关阅读:
    RIP动态路由协议详解
    关于单机流程编排技术——docker compose安装使用的问题
    【CFD小工坊】浅水模型的边界条件
    突然想散步
    关于 async 和 await 两个关键字（C#）【并发编程系列_5】
    面试经典150题——矩阵置零
    pikach靶场暴力破解
    JSR303数据校验方法
    TMUX终端复用工具小解
    自动切换背景的登录页面
  • 原文地址：https://blog.csdn.net/u013184970/article/details/127632801