多线程和消息机制

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3     xmlns:tools="http://schemas.android.com/tools"
 4     android:layout_width="match_parent"
 5     android:layout_height="match_parent"
 6     android:paddingBottom="@dimen/activity_vertical_margin"
 7     android:paddingLeft="@dimen/activity_horizontal_margin"
 8     android:paddingRight="@dimen/activity_horizontal_margin"
 9     android:paddingTop="@dimen/activity_vertical_margin"
10     tools:context="com.hanqi.testapp2.TestActivity6"
11     android:orientation="vertical">
12
13     <TextView
14         android:layout_width="match_parent"
15         android:layout_height="wrap_content"
16         android:text="城市1"
17         android:id="@+id/tv_3"/>
18     <TextView
19         android:layout_width="match_parent"
20         android:layout_height="wrap_content"
21         android:text="城市2"
22         android:id="@+id/tv_4"/>
23     <Button
24         android:layout_width="match_parent"
25         android:layout_height="wrap_content"
26         android:text="启动"
27         android:onClick="bt1_OnClick"/>
28
29     <TextView
30         android:layout_width="wrap_content"
31         android:layout_height="wrap_content"
32         android:text="接收的消息"
33         android:id="@+id/tv_5"/>
34
35     <Button
36         android:layout_width="match_parent"
37         android:layout_height="wrap_content"
38         android:text="发消息"
39         android:onClick="bt2_OnClick"/>
40
41     <TextView
42         android:layout_width="wrap_content"
43         android:layout_height="wrap_content"
44         android:text="10"
45         android:id="@+id/tv_6"
46         android:layout_gravity="center"/>
47
48     <Button
49         android:layout_width="match_parent"
50         android:layout_height="wrap_content"
51         android:text="增加"
52         android:onClick="bt3_OnClick"
53         android:id="@+id/bt_3"/>
54
55     <Button
56         android:layout_width="match_parent"
57         android:layout_height="wrap_content"
58         android:text="减少"
59         android:onClick="bt3_OnClick"
60         android:id="@+id/bt_4"/>
61
62     <Button
63         android:layout_width="match_parent"
64         android:layout_height="wrap_content"
65         android:text="暂停"
66         android:onClick="bt3_OnClick"
67         android:id="@+id/bt_5"
68         android:enabled="false"/>
69
70 </LinearLayout>
  1 package com.hanqi.testapp2;
  2
  3 import android.os.Handler;
  4 import android.os.Message;
  5 import android.support.v7.app.AppCompatActivity;
  6 import android.os.Bundle;
  7 import android.view.View;
  8 import android.widget.Button;
  9 import android.widget.TextView;
 10 import android.widget.Toast;
 11
 12 import java.util.Random;
 13
 14 public class TestActivity6 extends AppCompatActivity {
 15
 16     TextView tv_3, tv_4, tv_5,tv_6;
 17
 18     Button bt_3, bt_4, bt_5;
 19
 20     //定义Handler
 21     Handler h = new Handler(){
 22         @Override
 23         public void handleMessage(Message msg) {
 24             super.handleMessage(msg);
 25
 26             //处理消息
 27             if (msg.what == 1)
 28             {
 29                 String m = msg.obj.toString();
 30
 31                 tv_5.setText(tv_5.getText() + " " + m);
 32             }
 33             else if (msg.what == 2)
 34             {
 35                 tv_5.setText(tv_5.getText() + " 空消息");
 36             }
 37         }
 38     };
 39
 40     int i = 10;
 41
 42     Handler hl = new Handler()
 43     {
 44         @Override
 45         public void handleMessage(Message msg) {
 46             super.handleMessage(msg);
 47
 48             switch (msg.what)
 49             {
 50                 case 1:
 51
 52                     bt_3.setEnabled(false);
 53                     bt_4.setEnabled(true);
 54                     bt_5.setEnabled(true);
 55
 56                     if (i == 20)
 57                     {
 58                         bt_5.setEnabled(false);
 59                         return;
 60                     }
 61
 62                     i++;
 63
 64                     tv_6.setText(i + "");
 65
 66                     //发送
 67                     hl.sendEmptyMessageDelayed(1, 1000);
 68
 69                     hl.removeMessages(2);
 70
 71                     break;
 72
 73                 case 2:
 74
 75                     bt_3.setEnabled(true);
 76                     bt_4.setEnabled(false);
 77                     bt_5.setEnabled(true);
 78
 79                     if (i == 1)
 80                     {
 81                         bt_5.setEnabled(false);
 82                         return;
 83                     }
 84
 85                     i--;
 86
 87                     tv_6.setText(i + "");
 88
 89                     //发送
 90                     hl.sendEmptyMessageDelayed(2,1000);
 91
 92                     hl.removeMessages(1);
 93
 94                     break;
 95
 96                 case 3:
 97
 98                     bt_3.setEnabled(true);
 99                     bt_4.setEnabled(true);
100                     bt_5.setEnabled(false);
101
102                     hl.removeMessages(1);
103                     hl.removeMessages(2);
104
105                     break;
106             }
107         }
108     };
109
110     @Override
111     protected void onCreate(Bundle savedInstanceState) {
112         super.onCreate(savedInstanceState);
113         setContentView(R.layout.activity_test6);
114
115         tv_3 = (TextView)findViewById(R.id.tv_3);
116         tv_4 = (TextView)findViewById(R.id.tv_4);
117         tv_5 = (TextView)findViewById(R.id.tv_5);
118         tv_6 = (TextView)findViewById(R.id.tv_6);
119
120         bt_3 = (Button)findViewById(R.id.bt_3);
121         bt_4 = (Button)findViewById(R.id.bt_4);
122         bt_5 = (Button)findViewById(R.id.bt_5);
123     }
124
125
126     //3个按钮
127     public void bt3_OnClick(View v)
128     {
129         switch (v.getId())
130         {
131             case R.id.bt_3:
132
133                 //发送增加消息
134                 hl.sendEmptyMessage(1);
135
136                 break;
137
138             case R.id.bt_4:
139
140                 //发送减少消息
141                 hl.sendEmptyMessage(2);
142
143                 break;
144
145             case R.id.bt_5:
146
147                 //发送暂停消息
148                 hl.sendEmptyMessage(3);
149
150                 break;
151         }
152     }
153
154
155     //发消息
156     public void bt2_OnClick(View v)
157     {
158         //启动线程
159         new Thread(){
160             @Override
161             public void run() {
162
163                 //发送消息
164                 //1、创建Message
165                 Message m = Message.obtain();
166                 m.what = 1;//id
167                 m.obj = "新信息1";
168
169                 //2、发送即时消息
170                 h.sendMessage(m);
171
172                 m = Message.obtain();
173                 m.what = 1;//id
174                 m.obj = "新信息2";
175
176                 //发送延时消息
177                 h.sendMessageDelayed(m,2000);
178
179                 h.sendEmptyMessage(2);
180
181                 h.sendEmptyMessageDelayed(2,3000);
182             }
183         }.start();
184     }
185
186
187     public void bt1_OnClick(View v)
188     {
189         tv_3.setText("");
190         tv_4.setText("");
191
192         //创建子线程1
193         new Thread(){
194             @Override
195             public void run() {
196
197                 for (int i = 0; i<10; i++) {
198                     try {
199                         //暂停时间随机
200                         Thread.sleep(new Random().nextInt(2000));
201                     }
202                     catch (Exception e)
203                     {
204
205                     }
206
207                     runOnUiThread(new Runnable() {
208                         @Override
209                         public void run() {
210
211                           tv_3.setText(tv_3.getText() + "北京");
212                         }
213                     });
214
215                 }
216
217                 runOnUiThread(new Runnable() {
218                     @Override
219                     public void run() {
220                         Toast.makeText(TestActivity6.this, "北京 循环完成", Toast.LENGTH_SHORT).show();
221                     }
222                 });
223             }
224         }.start();
225
226
227
228         //创建子线程2
229         new Thread(){
230             @Override
231             public void run() {
232
233                 for (int i = 0; i<10; i++) {
234                     try {
235                         //暂停时间随机
236                         Thread.sleep(new Random().nextInt(2000));
237                     }
238                     catch (Exception e)
239                     {
240
241                     }
242
243                     runOnUiThread(new Runnable() {
244                         @Override
245                         public void run() {
246
247                             tv_4.setText(tv_4.getText() + "香港");
248                         }
249                     });
250
251                 }
252
253                 runOnUiThread(new Runnable() {
254                     @Override
255                     public void run() {
256                         Toast.makeText(TestActivity6.this, "香港 循环完成", Toast.LENGTH_SHORT).show();
257                     }
258                 });
259             }
260         }.start();
261     }
262 }

时间: 2024-10-29 00:20:21

多线程和消息机制的相关文章

Android多线程编程之Handler篇(消息机制)

Android多线程编程之Handler篇(消息机制) Android的消息机制主要是指Handler的运行机制,Handler的运行需要底层的MessageQueue和Looper的支撑. MessageQueue 消息队列,以队列的形式(实为单链表结构)对外提供插入和删除的工作, Looper 以无限循环的形式不断获取MessageQueue中的消息,有则处理,无则等待. ThreadLocal ThreadLocal可以在不同的线程互不干扰的存储并提供数据,通过ThreadLocal可以很

Android Handler AsyncTask 消息机制

一.Android消息机制一 Android 有一种叫消息队列的说法,这里我们可以这样理解:假如一个隧道就是一个消息队列,那么里面的每一部汽车就是一个一个消息,这里我们先忽略掉超车等种种因素,只那么先进隧道的车将会先出,这个机制跟我们android 的消息机制是一样的. 角色描述 1. Looper:(相当于隧道) 一个线程可以产生一个Looper 对象,由它来管理此线程里的Message Queue( 车队,消息隧道) . 2. Handler: 你可以构造Handler 对象来与Looper

深入解析Android中Handler消息机制

Android提供了Handler 和 Looper 来满足线程间的通信.Handler先进先出原则.Looper类用来管理特定线程内对象之间的消息交换(MessageExchange).Handler消息机制可以说是Android系统中最重要部分之一,所以,本篇博客我们就来深入解析Android中Handler消息机制. Handler的简单使用 为什么系统不允许子线程更新UI 因为的UI控件不是线程安全的. 如果在多线程中并发访问可能会导致UI控件处于不可预期的状态,那为什么不对UI控件的访

Android消息机制Handler解析(源码+Demo)

Handler是开发人员在面试过程中最常见的问题之一了,这篇文章将较为全面地对Handler进行解读,包括源码层,以及使用方法. 如果看完文章有疑问,欢迎在评论中一起探讨 基本内容包括: 看完文章之后,可以用这个图片进行复习. 一.什么是Handler Handler是Android提供用来更新UI的一套机制,也是一套消息处理机制,可以用它来发送消息,也可以用它来接收消息. 二.为什么使用Handler Android在设计之时,就封装了一套消息的创建.传递.处理机制,若不遵循这样的处理机制,就

Android消息机制

概述 作用 为什么不能在主线程中进行耗时操作? 因为会导致体验不流畅.卡顿,体验差. Handler的出现为了解决在子线程中操作完成了无法访问UI线程(主线程)的矛盾. 为什么不能在子线程中更新UI? 因为多线程操作导致线程不同步,并发操作让UI控件处于不可预期的状态. 为什么不通过线程同步更新UI?通过给UI控件的访问加上锁 1. 加锁会让UI访问逻辑变得异常复杂 2. 锁阻塞某些线程的执行,降低UI访问效率 ThreadLocal 为什么要使用ThreadLocal ThreadLocal的

Android学习笔记之消息机制

Android的消息机制主要是指Handler的运行机制以及Handler所附带的MessageQueue和Looper的工作过程.   1.为什么要使用Handler? Android规定访问UI只能在主线程中进行,如果在子线程中访问UI,则会抛出异常.同时Android建议不能在主线程中进行耗时的操作,不然会导致程序无法响应即ANR.因此耗时的工作只能交给子线程去做,而子线程却不能直接访问UI,为了解决这个矛盾,Android提供了Handler.Handler的主要作用是将某个任务切换到某

Android的消息机制Handler详解

Android的消息机制详解 Android的消息机制主要指 Handler 的运行机制,Handler的运行需要底层的MessageQueue 和 Looper 的支撑. MessageQueue:消息队列,它的内部存储了一组消息,以队列的形式对外提供插入和删除的工作,其内部存储结构采用单链表的数据结构来存储消息列表. Looper:可理解为消息循环. 由于MessageQueue只是一个消息存储单元,不能去处理消息,而Looper会以无限循环的形式去查找是否有新的消息,如果有的话就处理,否则

[转]Handler消息机制详解

能简单说得我们尽量不复杂: 为了避免ANR,我们会通常把 耗时操作放在子线程里面去执行,因为子线程不能更新UI,所以当子线程需要更新的UI的时候就需要借助到安卓的消息机制,也就是Handler机制了. 注意:在安卓的世界里面,当 子线程 在执行耗时操作的时候,不是说你的主线程就阻塞在那里等待子线程的完成--也不是调用 Thread.wait()或是Thread.sleep().安卓采取的方法是,主线程应该为子线程提供一个Handler,以便完成时能够提交给主线程.以这种方式设计你的应用程序,将能

Android消息机制(基于源码解析)

1. 消息机制概述 Android中的消息机制主要指的是Handler的运行机制,Handler的运行需要底层的MessageQueue和Looper.Message的支撑,下文会逐一分析. 2. 为什么需要消息机制 Android中的消息机制主要是为了满足线程间通信而设计的,最重要的应用场景应该在于更新UI Android规定访问UI只能在主线程中进行,如果在子线程中访问UI,那么程序就会抛出异常 系统为什么不允许在自线程中访问UI呢?这是因为Android的UI控件不是线程安全的,如果在多线