android的Handler

最新推荐文章于 2023-10-30 22:01:14 发布
最新推荐文章于 2023-10-30 22:01:14 发布
阅读量536 收藏
点赞数
分类专栏： Android 文章标签： android button layout timer date callback
前言

　　学习android一段时间了，为了进一步了解android的应用是如何设计开发的，决定详细研究几个开源的android应用。从一些开源应用中吸收点东西，一边进行量的积累，一边探索android的学习研究方向。这里我首先选择了jwood的  Standup Timer  项目。本文将把研究的内容笔记整理，建立一个索引列表。

关键词

　　Android.os.Handler涉及较多的知识点，我把一些关键词列举在下面，将主要介绍Handler：

android.os.Handler

　　Handler在android里负责发送和处理消息。它的主要用途有：
　　1）按计划发送消息或执行某个Runnanble(使用POST方法)；
　　2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新UI线程）
　　 默认情况下，Handler接受的是当前线程下的消息循环实例（使用Handler( Looper  looper)、 Handler ( Looper  looper,  Handler.Callback  callback)可以指定线程），同时一个消息队列可以被当前线程中的多个对象进行分发、处理（在UI线程中，系统已经有一个Activity来处理了，你可以再起若干个Handler来处理）。在实例化Handler的时候，Looper可以是任意线程的，只要有Handler的指针，任何线程也都可以sendMessage。Handler对于Message的处理不是并发的。一个Looper 只有处理完一条Message才会读取下一条，所以消息的处理是阻塞形式的（handleMessage()方法里不应该有耗时操作，可以将耗时操作放在其他线程执行，操作完后发送Message（通过sendMessges方法）,然后由handleMessage()更新UI）。

倒计时程序

　　利用Timer 编写一个倒计时程序，程序使用Timer和TimerTask来完成倒计时，同时使用sendMessages方法发送消息，然后在HanleMessage里更新UI。
Activity布局：
Layout 
       
       

        
        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--><?xml version="1.0" encoding="utf-8"?>
        
        

        
        <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        
        
    android:orientation
        
        ="vertical"
        
        
    android:layout_width
        
        ="fill_parent"
        
        
    android:layout_height
        
        ="fill_parent"
        
        
    
        
        >
        
        

        
        <
        
        TextView  
    android:layout_width="fill_parent"
        
         
    android:layout_height="wrap_content"
        
         
    android:layout_gravity="center"
        
        
    android:id
        
        ="@+id/txt"
        
        
    
        
        />
        
        

        
        <
        
        Button
    android:id="@+id/btnStartTime"
        
        
    android:text
        
        ="开始计时"
        
        
    android:layout_width
        
        ="80dip"
        
        
    android:layout_height
        
        ="wrap_content"
        
         

    ></Button>
        
        
 
        
        <
        
        Button
     android:id="@+id/btnStopTime"
        
        
     android:text
        
        ="停止计时"
        
        
     android:layout_width
        
        ="80dip"
        
        
    android:layout_height
        
        ="wrap_content"
        
        
  
        
        />
        
        
  

        
        <SeekBar android:id="@+id/SeekBar01" android:layout_width="match_parent" android:layout_height="wrap_content"></SeekBar>
        
        

        
        </LinearLayout>

 

这里使用TextView 来显示倒计时的时间变化，两个按钮用于控制时间的开始和停止。SeekBar主要是用于查看线程是否被阻塞（阻塞时无法拖动）。
onCreate 
       
       

        
        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        
        @Override
    public void
        
         onCreate(Bundle savedInstanceState) {
        super
        
        .onCreate(savedInstanceState);
        setContentView(R.layout.main);
        txt =
        
         (TextView) findViewById(R.id.txt);
        btnStart =
        
         (Button) findViewById(R.id.btnStartTime);
        btnStop =
        
         (Button) findViewById(R.id.btnStopTime);
        Log.d("ThreadId", "onCread:"
        
        
                
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
        myHandler = new Handler(this
        
        );

        btnStart.setOnClickListener(this
        
        );
        btnStop.setOnClickListener(this
        
        );

    }

 

在onCreate方法中初始化元素个元素，myHandler = new Handler(this); 调用的是  Handler( Handler.Callback  callback)构造函数，在回调方法callback中对发送来的消息进行处理（这样我们就不必使用内部类的写法来 重写HandleMessage()方法了），因此Activity必须实现  android.os.Handler.Callback  接口。我们还在将onCreate 方法的ThreadId 记录在了Log中用以和消息发送、处理时所作的线程进行比较。
发送消息 
       
       

        
        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        
        
    @Override
    
        
        public void
        
         onClick(View v) {
        switch
        
         (v.getId()) {
        case
        
         R.id.btnStartTime:
            startTimer();
            break
        
        ;
        case
        
         R.id.btnStopTime:
            timer.cancel();

            break
        
        ;
        }

    }

    private synchronized void
        
         startTimer() {

        timer = new
        
         Timer();
        //
        
         TimerTask updateTimerValuesTask = new TimerTask() {
        //
        
         @Override
        //
        
         public void run() {
        //
        
         updateTimerValues();
        //
        
         }
        //
        
        
        
        
        //
        
         };
        //自定义的CallBack模式。Task继承自TimerTask
        
        

        
                Task updateTimerValuesTask = new Task(this
        
        );

        timer.schedule(updateTimerValuesTask, 1000, 1000
        
        );
    }

    //执行耗时的倒计时任务。
        
        

        
            private void
        
         updateTimerValues() {
        total--
        
        ;

        Log.d("ThreadId", "send:"
        
        
                
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
        
        Message msg=new
        
         Message();
        Bundle date = new Bundle();// 存放数据
        
        

        
                date.putInt("time"
        
        , total);
        msg.setData(date);
        msg.what=0
        
        ;
        myHandler.sendMessage(msg);

        //
        
        另一种写法
//
        
                Message msg=myHandler.obtainMessage();
//        Bundle date = new Bundle();//
        
         存放数据
//
        
                date.putInt("time", total);
//
        
                msg.setData(date);
//
        
                msg.what=0;
//        msg.sendToTarget();
        
        

        
                
    }

    @Override
    public void
        
         TaskRun() {
        updateTimerValues();

    }

 

实现Button按钮的事件处理以此进入倒计时操作。这里使用的Timer 来执行定时操作（其实我们完全可以另起一个线程）。Task类继承了TimerTask类,里面增加了一个任务处理接口来实现回调模式，应此Activity需要实现该回调的接口 ITaskCallBack（这样做是因为我比较不喜欢内部类的编写方法）。
ICallBack接口和Task类 
       
       

        
        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->public interface
        
         ITaskCallBack {

    void
        
         TaskRun();
}



public class Task extends
        
         TimerTask {

    private
        
         ITaskCallBack iTask;
    
    public
        
         Task(ITaskCallBack iTaskCallBack)
    {
        super
        
        ();
        iTask=
        
        iTaskCallBack;
    }
    
    public void
        
         setCallBack(ITaskCallBack iTaskCallBack)
    {
        iTask=
        
        iTaskCallBack;
    }
    @Override
    public void
        
         run() {
        // TODO Auto-generated method stub
        
        

        
                iTask.TaskRun();
    }

}

 

这是Java的回调函数的一般写法。
实现CallBack 
       
       

        
        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        
        
    
        
        /**
        
        
     * 实现消息处理
     
        
        */
        
        
    @Override
    
        
        public boolean
        
         handleMessage(Message msg) {
    
        switch
        
        (msg.what)
        {
        case 0
        
        :
            Bundle date=
        
        msg.getData();
            txt.setText(String.valueOf(date.getInt("time"
        
        )));
            
            Log.d("ThreadId", "HandlerMessage:"
        
        
                    
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
            Log.d("ThreadId", "msgDate:"
        
        
                    
        
        + String.valueOf(date.getInt("time"
        
        )));
            break
        
        ;

        }
        return false
        
        ;
    }

 

运行结果

　　可以看到在onCreate 方法中线程的ID是1（UI线程） 这与 HandlerMessage 进行消息处理时是所作的线程ID是一样的，而消息发送的线程ID则为8非UI线程。

使用Threadle进行实现

Activity类 
       
       

        
        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        
        

        
        public class ThreadHandlerrActivity extends Activity implements
        
         Callback,
        OnClickListener {

    private
        
         TextView txt;
    private
        
         Button btnStart, btnStop;
    private
        
         Handler myHandler;
    private
        
         TimerThread timerThread;
    private int Total=30
        
        ;


    /** Called when the activity is first created. */
        
        
    @Override
    
        
        public void
        
         onCreate(Bundle savedInstanceState) {
        super
        
        .onCreate(savedInstanceState);
        setContentView(R.layout.main);
        txt =
        
         (TextView) findViewById(R.id.txt);
        btnStart =
        
         (Button) findViewById(R.id.btnStartTime);
        btnStop =
        
         (Button) findViewById(R.id.btnStopTime);
        Log.d("ThreadId", "onCread:"
        
        
                
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
        myHandler = new Handler(this
        
        );
        
    
        btnStart.setOnClickListener(this
        
        );
        btnStop.setOnClickListener(this
        
        );

    }

    /**
        
        
     * 实现消息处理
     
        
        */
        
        
    @Override
    
        
        public boolean
        
         handleMessage(Message msg) {
    
        switch
        
        (msg.what)
        {
        case 0
        
        :
            Bundle date=
        
        msg.getData();
            txt.setText(String.valueOf(date.getInt("time"
        
        )));
            
            Log.d("ThreadId", "HandlerMessage:"
        
        
                    
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
            Log.d("ThreadId", "msgDate:"
        
        
                    
        
        + String.valueOf(date.getInt("time"
        
        )));
            break
        
        ;

        }
        return false
        
        ;
    }

    @Override
    public void
        
         onClick(View v) {
        switch
        
         (v.getId()) {
        case
        
         R.id.btnStartTime:
            //自定义的线程
        
        

        
                timerThread=new TimerThread(myHandler,60
        
        );
            timerThread.start();
            
            break
        
        ;
        case
        
         R.id.btnStopTime:
            timerThread.stop();
            //timerThread.destroy();
        
        

        
                    break
        
        ;
        }

    }

    
        
    
}

 

自定义的线程类 
       
       

        
        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->**
        
        
 
        
        *
        
         自定义的线程类，通过传入的Handler,和Total 定期执行耗时操作
 *
        
         @author linzijun
 *
        
        
 
        
        */
        
        

        
        public class TimerThread extends
        
         Thread  {

    public int Total=60
        
        ;
    public
        
         Handler handler;
    /**
        
        
     * 初始化构造函数
     * 
        
        @param
        
         mhandler handler 用于发送消息
     * @param
        
         total 总周期
     */
        
        
    
        
        public TimerThread(Handler mhandler,int
        
         total)
    {
        super
        
        ();
        handler=
        
        mhandler;
        Total=
        
        total;
    }
    @Override
    public void
        
         run() {
        
        while(true
        
        )
        {
            Total--
        
        ;
            if(Total<0
        
        )
                break
        
        ;
            try
        
         {
                Thread.sleep(1000
        
        );
            } catch
        
         (InterruptedException e) {
                // TODO Auto-generated catch block
        
        

        
                        e.printStackTrace();
            }
            Message msg=new
        
         Message();
            Bundle date = new Bundle();// 存放数据
        
        

        
                    date.putInt("time"
        
        , Total);
            msg.setData(date);
            msg.what=0
        
        ;
            Log.d("ThreadId", "Thread:"
        
        
                    
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
            handler.sendMessage(msg);
            
            
        }
        
        super
        
        .run();
    }

    
    
}

 

这里继承了Thread类，也可以直接实现 Runnable接口。

关于POST

　　Post的各种方法是把一个Runnable发送给消息队列，它将在到达时进行处理。
POST 
       
       

        
        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        
        

        
        public class PostHandler extends Activity implements
        
         OnClickListener, Runnable {

    private
        
         TextView txt;
    private
        
         Button btnStart, btnStop;
    private
        
         Handler myHandler;
    private
        
         Timer timer;
    private int total = 60
        
        ;

    
    @Override
    protected void
        
         onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        
        

        
                super
        
        .onCreate(savedInstanceState);

        setContentView(R.layout.main);
        txt =
        
         (TextView) findViewById(R.id.txt);
        btnStart =
        
         (Button) findViewById(R.id.btnStartTime);
        btnStop =
        
         (Button) findViewById(R.id.btnStopTime);
        Log.d("ThreadId", "onCread:"
        
        
                
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
        myHandler = new
        
         Handler()
        {

            @Override
            public void
        
         handleMessage(Message msg) {
                switch
        
        (msg.what)
                {
                case 0
        
        :
                    Bundle date=
        
        msg.getData();
                    txt.setText(String.valueOf(date.getInt("time"
        
        )));
                    
                    Log.d("ThreadId", "HandlerMessage:"
        
        
                            
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
                    Log.d("ThreadId", "msgDate:"
        
        
                            
        
        + String.valueOf(date.getInt("time"
        
        )));
                    break
        
        ;

                }
    
            }
            
        };

        btnStart.setOnClickListener(this
        
        );
        btnStop.setOnClickListener(this
        
        );
    }

    @Override
    public void
        
         onClick(View v) {
        switch
        
         (v.getId()) {
        case
        
         R.id.btnStartTime:
            //myHandler.post(this);
        
        

        
                    myHandler.postDelayed(this, 1000
        
        );
            break
        
        ;
        case
        
         R.id.btnStopTime:
            
            break
        
        ;
        }
        
    }

    @Override
    public void
        
         run() {
        while(true
        
        )
        {
            total--
        
        ;
            if(total<0
        
        )
                break
        
        ;
            try
        
         {
                Thread.sleep(1000
        
        );
            } catch
        
         (InterruptedException e) {
                // TODO Auto-generated catch block
        
        

        
                        e.printStackTrace();
            }
            Message msg=new
        
         Message();
            Bundle date = new Bundle();// 存放数据
        
        

        
                    date.putInt("time"
        
        , total);
            msg.setData(date);
            msg.what=0
        
        ;
            Log.d("ThreadId", "POST:"
        
        
                    
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
            myHandler.sendMessage(msg);
            Log.d("ThreadId", "Thread:"
        
        
                    
        
        +
        
         String.valueOf(Thread.currentThread().getId()));

        }
        
    }

}

 

使用POST的方式 是将Runnable 一起发送给处理的线程（这里为UI），如果Runnable的操作比较耗时的话那线程将进入阻塞状态。可以看到先运行 Runnable的Run方法 然后在进入 HandleMessage（） 。我还尝试了另一种写法，将TimerThreadPOST过去，运行结果是一样的。
代码 
       
       

        
        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->package
        
         zijunlin.me;

import
        
         java.util.Timer;

import
        
         android.app.Activity;
import
        
         android.os.Bundle;
import
        
         android.os.Handler;
import
        
         android.os.Message;
import
        
         android.util.Log;
import
        
         android.view.View;
import
        
         android.view.View.OnClickListener;
import
        
         android.widget.Button;
import
        
         android.widget.TextView;

public class PostHandler extends Activity implements
        
         OnClickListener, Runnable {

    private
        
         TextView txt;
    private
        
         Button btnStart, btnStop;
    private
        
         Handler myHandler;
    private
        
         Timer timer;
    private int total = 60
        
        ;
    private
        
         TimerThread timerThread;
    
    @Override
    protected void
        
         onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        
        

        
                super
        
        .onCreate(savedInstanceState);

        setContentView(R.layout.main);
        txt =
        
         (TextView) findViewById(R.id.txt);
        btnStart =
        
         (Button) findViewById(R.id.btnStartTime);
        btnStop =
        
         (Button) findViewById(R.id.btnStopTime);
        Log.d("ThreadId", "onCread:"
        
        
                
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
        myHandler = new
        
         Handler()
        {

            @Override
            public void
        
         handleMessage(Message msg) {
                switch
        
        (msg.what)
                {
                case 0
        
        :
                    Bundle date=
        
        msg.getData();
                    txt.setText(String.valueOf(date.getInt("time"
        
        )));
                    
                    Log.d("ThreadId", "HandlerMessage:"
        
        
                            
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
                    Log.d("ThreadId", "msgDate:"
        
        
                            
        
        + String.valueOf(date.getInt("time"
        
        )));
                    break
        
        ;

                }
    
            }
            
        };

        btnStart.setOnClickListener(this
        
        );
        btnStop.setOnClickListener(this
        
        );
    }

    @Override
    public void
        
         onClick(View v) {
        switch
        
         (v.getId()) {
        case
        
         R.id.btnStartTime:
            //
        
        myHandler.post(this);
            //myHandler.postDelayed(this, 1000);
        
        

        
                    timerThread=new TimerThread(myHandler,60
        
        );
            
            myHandler.post(timerThread);
            break
        
        ;
        case
        
         R.id.btnStopTime:
            
            break
        
        ;
        }
        
    }

    @Override
    public void
        
         run() {
        while(true
        
        )
        {
            total--
        
        ;
            if(total<0
        
        )
                break
        
        ;
            try
        
         {
                Thread.sleep(1000
        
        );
            } catch
        
         (InterruptedException e) {
                // TODO Auto-generated catch block
        
        

        
                        e.printStackTrace();
            }
            Message msg=new
        
         Message();
            Bundle date = new Bundle();// 存放数据
        
        

        
                    date.putInt("time"
        
        , total);
            msg.setData(date);
            msg.what=0
        
        ;
            Log.d("ThreadId", "POST:"
        
        
                    
        
        +
        
         String.valueOf(Thread.currentThread().getId()));
            myHandler.sendMessage(msg);
            Log.d("ThreadId", "Thread:"
        
        
                    
        
        +
        
         String.valueOf(Thread.currentThread().getId()));

        }
        
    }

}

 

可以说POST的各种方法主要是用于 “按计划发送消息或执行某个Runnanble(使用POST方法)”。

参考文献

　　 SDK

straing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android Handler工作原理解析
08-31
主要为大家详细介绍了Android Handler的原理，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android——Handler详解
热门推荐
Yawn
05-27 6万+
1. 简介 Handler是一套 Android 消息传递机制 可以说只要有异步线程与主线程通信的地方就一定会有 Handler。 在多线程的应用场景中，将工作线程中需更新UI的操作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理 使用Handler消息传递机制主要是为了多个线程并发更新UI的同时，保证线程安全 2. 相关概念解释 Handler、Message、Message Queue、Looper Android消息机制： 以Handler的sendMes
Android之Handle全面理解
深红骑士的博客
05-22 2万+
一.什么是Handler    Handler是Android给我们提供用来更新UI的一套机制，是一套消息处理机制，可以通过它来发送消息和处理消息。那作为开发者的我们，不禁会疑问？Google为什么要设计这套机制呢？这是为了解决在非UI线程中更新UI组件比较麻烦的问题。那么Android为什么不能在非UI线程中更新呢？首先Android的UI控件不是线程安全的，这是因为避免多线程并发所带来不安全问...
Android——Handler一篇就看懂
未来源起的博客
06-07 3926
Android handler的详细讲解
Android的Handler机制原理详解
最新发布
夏夏的博客
10-30 1330
在实际开发中，三种方法的使用都可行，具体用哪种方法，需结合你的实际情况及个人喜好。另外，在实际使用中往往将 Handler 写成静态内部类，这时需要注意防止内存泄露！（The handler class should be static or leaks might occur），具体代码见上方！如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。
Android系统Handler详解
allen_xu_2012_new的博客
06-11 2072
Handler是一套 Android 消息传递机制,主要用于线程间通信。用最简单的话描述： handler其实就是主线程在起了一个子线程，子线程运行并生成Message，Looper获取message并传递给Handler，Handler逐个获取子线程中的Message.Binder/Socket用于进程间通信，而Handler消息机制用于同进程的线程间通信可以说只要有异步线程与主线程通信的地方就一定会有 Handler。
Android Handler解析
03-17
Android Handler详细解析，讲解Handler之间的通讯，叫你如果用Handler完成异步线程对 UI的更新
android handler例子
07-02
比较简单的handler例子，通过接受消息改变图片展示
Android Handler Looper
05-11
Android Handler Looper
Android Handler的详细介绍
01-05
Handler的定义　主要接受子线程发送的数据, 并用此数据配合主线程更新UI.　解释: 当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发。 　比如说, 你要是...
Android-Handle详解
yuqing_1102的专栏
02-10 3410
（学习Mooc的笔记） 转载请标明出处：1.handle是什么？handle是android提供用来更新UI的一套机制，也是一套信息处理机制，可以发送消息，也可以通过它处理消息。 2.handle用法注意：其中Runnable是在UI线程中调用的方法。 (1)handle.post(Runnable); (2)handle.postDelayed(Runnable, long);其中
安卓软件开发！你所不知道的Android原生开发的现状，附超全教程文档
chayel123的博客
01-28 729
前言： 笔者出生在江西一个偏远的山村。虽然出生时已经不是那个温饱都是问题的年代，但是也谈不上有个幸福的童年。家里很穷。幼儿园并没有读，因为家里觉得花那个钱没有必要，小学才开始学拼音字母。我的童年，就是和我的姐姐弟弟在山中的梯田里放牛，抓泥鳅，割鱼草。 大学上的是北大青鸟，一个成人培训机构，没有学历。在深圳打拼了6年了，一直在一些小公司打转。年初疫情突然爆发，市场经济进入寒冬，我也被公司裁员了。 这也让我意识到，本身学历就不高，如果还不发奋让自己的技术更上一个层次的话，肯定是没有未来可言的。幸而有朋友在阿里任
【Android】Handler机制详解
helloworld370629的博客
10-17 1892
Android异步通信Handler详解，使用方式，源码分析
Android基础学习（二十一）—— Handler
123
12-09 1367
android基础之Handler
android handler使用
Warden032的博客
08-05 820
Handler：是一个消息分发对象，进行发送和处理消息，并且其 Runnable 对象与一个线程的 MessageQueue 关联。 作用：调度消息，将一个任务切换到某个指定的线程中去执行。 为什么需要 Handler？ 子线程不允许访问 UI 假若子线程允许访问 UI，则在多线程并发访问情况下，会使得 UI 控件处于不可预期的状态。 传统解决办法：加锁，但会使得UI访问逻辑变的复杂，其
ESP8266—物联网开发
qq_46496768的博客
09-20 773
123。
Android学习之路(13) Handler详解
qq_32907491的博客
09-03 2761
普通的线程是没有looper的，如果需要looper对象，那么必须要先调用Looper.prepare方法，而且一个线程只能有一个looperHandler是如何完成跨线程通信的？Android中采用的是Linux中的 管道通信关于管道，简单来说，管道就是一个文件在管道的两端，分别是两个打开文件文件描述符，这两个打开文件描述符都是对应同一个文件，其中一个是用来读的，别一个是用来写的消息队列创建时调用JNI函数，初始化NativeMessageQueue对象。
Android Handle 源码解析
风的轨迹
05-15 317
1.对Handle的认识 Handle机制是一个消息管理机制，Handle在Android的整个系统架构中处于核心的位置。所有的点击事件、滑动事件、页面跳转、服务启动等等，都是Handle消息机制驱动的，线程切换只是Handle的一个附属功能，所以做Android移动端研发必须对Handle机制有深入的理解。 2.Handle消息机制的运转流程分析 2.1消息的发送流程源码分析 //发送消息 public final boolean sendMessage(@NonNull Message m
Android Button click 事件监听
Yano_nankai的博客
01-03 1003
Activity 实现 android.view.View.OnClickListener。 public class MainActivity extends Activity implements android.view.View.OnClickListener { private Button button1, button2, button3; @Overrid
android Handler
06-07
Android Handler 是一种用于在不同线程之间传递消息和进行任务调度的机制。它可以将消息或任务放入消息队列中，并在指定的时间或条件下执行。在 Android 应用中，通常将 Handler 与 Looper 和 MessageQueue 一起使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值