精华内容
下载资源
问答
  • public class FinalActivity extends AppCompatActivity { private TextView tvFinal;... private static Handler h; @Override protected void onCreate(Bundle savedInstanceState) { supe...
    public class FinalActivity extends AppCompatActivity {
    
        private TextView tvFinal;
        private static Handler h;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_final);
            findViewById(R.id.btn_next).setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    LogUtils.w("click............");
                    h.sendEmptyMessage(1);
                }
            });
            tvFinal = findViewById(R.id.final_tv);
    
            new Thread(new Runnable() {
                @SuppressLint("HandlerLeak")
                @Override
                public void run() {
                    Looper.prepare();
                    h = new Handler(Looper.myLooper()) {
                        @Override
                        public void handleMessage(Message msg) {
                            super.handleMessage(msg);
                            String text = "改变了" + new Random().nextInt(1000);
                            LogUtils.w("text:" + text);
    
                        }
                    };
                    Looper.loop();
                }
            }).start();
        }
    
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            LogUtils.w("destroy....");
            if (h != null) {
                h.removeCallbacksAndMessages(null);
            }
        }
    }

    代码是示例代码,但是简单明了,子线程更新 UI,就这样写就可以了。

    展开全文
  • android子线程handler获取数据

    千次阅读 2016-02-22 15:28:18
    今天和大家分享下android 获取接口时,开通子线程进行异步获取数据。 我这边选用的是handler机制。在handler有多种获取方法。今天介绍的是一种比较流行,效率较高的一种方法:obtainMessage()。这种用的相对较少,...

    今天和大家分享下android 获取接口时,开通子线程进行异步获取数据。

    我这边选用的是handler机制。在handler有多种获取方法。今天介绍的是一种比较流行,效率较高的一种方法:obtainMessage()。这种用的相对较少,毕竟常见的是sendMessage()。我们先来对比下,首先看sendMessage的写法



    private Handler handler = new Handler() {
    @SuppressLint("ShowToast")
    @Override
    public void handleMessage(Message msg) {
    if (!Thread.currentThread().isInterrupted()) {
    switch (msg.what) {
    case 0:
     
    case 1:
     
    break;
    case 2:
     
    break;
    case -1:
     
    break;
    }
    }
    super.handleMessage(msg);
    }
    };

    private void sendMsg(int flag) {
    Message msg = new Message();
    msg.what = flag;
    handler.sendMessage(msg);
    }

    使用的话直接就是 sendMsg(1);

    源码为:

    1. /** 
    2.     * Returns a new {@link android.os.Message Message} from the global message pool.  
    3.   * More efficient than creating and allocating new instances.  
    4.    * The retrieved message has its handler set to this instance     
    5.   * (Message.target == this). 
    6.     * If you don't want that facility, just call Message.obtain() instead. 
    7.     */  
    8.     
    9.   
    10.    public final Message obtainMessage()  
    11.    {  
    12.        return Message.obtain(this);  
    13.    }  

    而obtainMessage()的使用是:

    private Handler mHandler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            if (“当前activity”!= null && !"当前activity".isFinishing()) {
                Result result = (Result) msg.obj;
                if (result != null) {
                    List<Qiang> qiangs = result.getData();
                    if (qiangs != null) {
                        mAdapter.setQiangs(qiangs);
                    }
                }
            }
            return false;
        }
    });
    
    mHandler.obtainMessage(0, result).sendToTarget();//result是object类型的,可以看下源码
    public final Message obtainMessage(int what, Object obj)
    {
        return Message.obtain(this, what, obj);
    }
    我们在看看sendToTargt()的源码:
    /**
     * Pushes a message onto the end of the message queue after all pending messages
     * before the current time. It will be received in {@link #handleMessage},
     * in the thread attached to this handler.
     *  
     * @return Returns true if the message was successfully placed in to the 
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.
     */
    public final boolean sendMessage(Message msg)
    {
        return sendMessagmeDelayed(msg, 0);
    }
    备注中写的比较详细了,这个msg不是new出来的,而是message queue中的,省去了对象申请的内存,
    建议大家还是按照obtainMessage()的写法来写:)

    展开全文
  • Android 子线程子线程通过Handler通信1、创建发送消息的子线程2、创建接收消息的子线程3、编辑主函数4、编写布局文件5、运行并观察结果 1、创建发送消息的子线程 创建一个Thread1类 import android.os.Handler; ...

    1、创建发送消息的子线程

    创建一个Thread1类

    import android.os.Handler;
    import android.os.Message;
    import android.os.SystemClock;
    
    //发送消息的子线程
    public class Thread1 extends Thread {
        private Handler handler;
    
        public Thread1(Handler handler){
            super.setName("Thread1");
            this.handler=handler;
        }
        @Override
        public void run() {
            Message msg = Message.obtain();
            msg.what = 1;
            msg.obj = System.currentTimeMillis()+"";
            handler.sendMessage(msg);
            System.out.println((Thread.currentThread().getName() + "----发送了消息!" + msg.obj));
            SystemClock.sleep(1000);
        }
    }
    

    2、创建接收消息的子线程

    创建一个Thread2类

    import android.os.Handler;
    import android.os.Looper;
    
    //接收消息的子线程
    public class Thread2 extends Thread{
        private Handler handler2;
        public Handler getHandler(){//注意哦,在run执行之前,返回的是null
            return handler2;
        }
        public Thread2(){
            super.setName("Thread2");
        }
        @Override
        public void run() {
            //在子线程里面新建Handler的实例,需要先调用Looper.prepare();否则会报错:Can't create handler inside thread that has not called Looper.prepare()
            Looper.prepare();
            handler2 = new Handler(){
                public void handleMessage(android.os.Message msg) {
                    //这里处理消息
                    System.out.println(("收到消息了:" + Thread.currentThread().getName() + "----" + msg.obj));
                };
            };
            Looper.loop();
    
        }
    }
    

    3、编辑主函数

    编辑MainActivity.class

    import android.os.Handler;
    import android.os.SystemClock;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    
    
    public class MainActivity extends AppCompatActivity{
        private Handler myHandler=null;
        private Thread2 thread1;
        private Thread1 thread2;
        private Button button;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            button = (Button)findViewById(R.id.handler3);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    //在当前onclick方法中监听点击button的动作
                    thread1 = new Thread2();
                    thread1.start();
                    myHandler = thread1.getHandler();
                    while (myHandler == null) {
                        SystemClock.sleep(100);
                        myHandler = thread1.getHandler();
                    }
                    thread2 = new Thread1(myHandler);
                    thread2.start();
                }
            });
        }
    }
    
    

    4、编写布局文件

    activity_main.xml

    <?xml version="1.0" encoding="utf-8"?>
    <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"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context="com.example.kh17_1.MainActivity">
    
        <Button
            android:id="@+id/handler3"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="启动子线程之间的通信" />
    </RelativeLayout>
    

    5、运行并观察结果

    得到该输出: 在这里插入图片描述
    两子线程成功实现通信~

    展开全文
  • android 子线程使用handler通信

    千次阅读 2019-03-28 11:11:27
    我们日常使用处理线程间的通信是 主线与子线程之间相互通信,也就是使用android提供的handler。 那么子线程之间如何相互通信呢?一般有可能会使用 全局变量来进行通信,其实我们也可以使用系统提供的handler来...

      我们日常使用处理线程间的通信是 主线程与子线程之间相互通信,也就是使用android提供的handler。

      那么子线程之间如何相互通信呢?一般有可能会使用 全局变量来进行通信,其实我们也可以使用系统提供的handler来进行子线程中的通信。

     handler的通信机制

    此处引用:https://blog.csdn.net/blackzhangwei/article/details/51945516

    由上图可以看出  handler负责消息的处理和发送的,messageQueue 是存储消息队列的,Looper 是处理消息的

    主线程在创建时或创建 looper 所以我们子线程可以和主线程通信,那么由此我们也可以在子线程中创建looper 来实现子线程中的通信。

    线程1

    Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                handler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        Log.e("Data", "handleMessage: " + msg.obj.toString());
                    }
                };
                Looper.loop();
            }
        };

    线程2

    Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                //Looper looper = Looper.myLooper();
                Message message = handler.obtainMessage();
                message.obj = "你好啊,线程一";
                handler.sendMessage(message);
            }
        };

    线程二中使用的 handler 是线程一中创建的 handler

    线程一中使用的looper方法

    Looper.prepare();   将当前线程初始化为 消息线程   

    Looper.loop();  在此线程中运行 消息队列

    那么如何停止运行呢

    Looper.quit();   停止运行消息队列,不处理任何消息。

    更多looper方法 

    https://developer.android.google.cn/reference/android/os/Looper.html

    英文是半吊子的,可以像我一样翻译网页。 ??

    展开全文
  • Android 子线程创建handler

    千次阅读 2017-12-24 22:55:05
    据上篇我转载的 Handler,Looper, Message 三者关系深入消化,理解后。我们会很清楚地使用了子线程和Ui线程通信的问题。 即解决了一个网络请求成功或者失败后,通知ui线程更新界面的case。 但是有人会疑问,那子线程...
  • 主线处理handler,大家都比较熟悉了,就是通过在onCreat中,new Handler  handler = new Handler(new Handler.Callback() { @Override public boolean handleMessage(Message msg) { System.out.println(...
  • 如果我们想在子线程上创建Handler,通过直接new的出来是会报异常的比如: [java] view plain copy newThread(newRunnable(){ publicvoidrun(){ Handlerhandler=newHandler(){ ...
  • 子线程控制主线程中的组件使用handler 比较好,但有时也可以用下面的方法来实现同样的效果: 此处是demo public class MainActivity extends Activity { private ImageView IV; private Button addBtn; @...
  • Android子线程更新UI主线程方法之Handler 背景: 我们开发应用程序的时候,处于线程安全的原因子线程通常是不能直接更新主线程(UI线程)中的UI元素的,那么在Android开发中有几种方法解决这个问题,其中...
  • android Handler子线程计算斐波那契数列
  • Android Handler(二)子线程子线程通信

    千次阅读 2018-06-22 17:53:19
    Android Handler(二)子线程子线程通信 子线程和子线程间通过Handler通信 发送消息的子线程 package com.cdc.handler; import android.os.Handler; import android.os.Message; import android.os.System...
  • 03-17 08:10:18.760 16029-16029/tech.androidstudio.tulingdemo E/AndroidRuntime: FATAL EXCEPTION: main 03-17 08:10:18.760 16029-16029/tech.androidstudio.tulingdemo E/AndroidRuntime: Process: tech.andro
  • 面试官: Handler中有Loop死循环,为什么没有阻塞主线,原理是什么心理分析:该问题很难被考到,但是如果一旦问到,100%会回答不上来。开发者很难注意到一个主线的四循环居然没有阻塞住主线求职者:应该从 主线...
  • 上一篇博客介绍了Android异步消息处理机制,如果你还不了解,可以看:Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系 。那篇博客的最后,提出可以把异步消息处理机制不仅仅是在...
  • 使用handler进行子线程之间通信
  • Android子线程间通信

    2017-06-15 20:12:15
    Android子线程间通信 looper默认存在于主线程中,在子线程和主线程通信时,子线程通过主线程中的handler发送消息给主线程的messageQueen消息队列,通过主线程中的looper取出,在handleMessage方法里可以使用...
  • Android子线程控制主线程UI 更新线程: 1 Handler mainHandler = new Handler(Looper.getMainLooper()){ 2 /*public void handleMessage(Message msg){ 3 if(msg.arg1 =...
  • 前言 ...后来发现 Handler 十分好用,通过 FutuerTask 反馈识别任务是否完成,未完成就由 Handler sendMessage 到 ui 线程去更新 ProgressBar进度条状态,这里设计了一个接口类和一个线程类,适合...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,939
精华内容 775
关键字:

android子线程handler