Android中的Handler

最新推荐文章于 2024-04-08 20:52:01 发布
最新推荐文章于 2024-04-08 20:52:01 发布
阅读量740 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dcking/article/details/10919627
版权

1、主线程给自己发送Message

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {

                Looper looper = Looper.getMainLooper(); // 主线程的Looper对象,Looper looper2 = Looper.myLooper(); // looper == looper2
                // 这里以主线程的Looper对象创建了handler，
                // 所以，这个handler发送的Message会被传递给主线程的MessageQueue。
                mHandler = new LocalHandler(looper);
                mHandler.removeMessages(0);

                // 构建Message对象
                // 第一个参数：是自己指定的message代号，方便在handler选择性地接收
                // 第二三个参数没有什么意义
                // 第四个参数需要封装的对象
                Message msg = mHandler.obtainMessage(1, 2, 3, "主线程发消息了");

                mHandler.sendMessage(msg); // 发送消息
            }
        });
    }

    class LocalHandler extends Handler {

        public LocalHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    }
}

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                mHandler.obtainMessage(1, "主线程发消息了").sendToTarget();
            }
        });
    }
}

2、其他线程给主线程发送Message

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 可以看出这里启动了一个线程来操作消息的封装和发送的工作
                // 这样原来主线程的发送就变成了其他线程的发送，简单吧？呵呵
                new LocalThread().start();
            }
        });
    }

    // 加了一个线程类
    class LocalThread extends Thread {

        @Override
        public void run() {
            Looper looper = Looper.getMainLooper(); // 主线程的Looper对象，// Looper looper2 = Looper.myLooper(); // looper2 == null
            // 这里以主线程的Looper对象创建了handler，
            // 所以，这个handler发送的Message会被传递给主线程的MessageQueue。
            mHandler = new LocalHandler(looper);

            // 构建Message对象
            // 第一个参数：是自己指定的message代号，方便在handler选择性地接收
            // 第二三个参数没有什么意义
            // 第四个参数需要封装的对象
            Message msg = mHandler.obtainMessage(1, 2, 3, "其他线程发消息了");

            mHandler.sendMessage(msg); // 发送消息
        }
    }

    class LocalHandler extends Handler {

        public LocalHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    }
}

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private final Handler mHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                new LocalThread().start();
            }
        });
    }

    // 加了一个线程类
    class LocalThread extends Thread {

        @Override
        public void run() {
            mHandler.obtainMessage(1, "其他线程发消息了").sendToTarget();
        }
    }
}

3、主线程给其他线程发送Message 

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mThreadHandler;
    private Handler mMainHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

                // 启动线程
        new MyThread().start();

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 这里handler的实例化在线程中
                // 线程启动的时候就已经实例化了
                Message msg = mThreadHandler.obtainMessage(1, "主线程发送的消息");
                mThreadHandler.sendMessage(msg);
            }
        });
    }

    class MyHandler extends Handler {

        public MyHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
        }
    }

    class MyThread extends Thread {

        @Override
        public void run() {
            Looper.prepare(); // 创建该线程的Looper对象，用于接收消息

            // 注意了：这里的handler是定义在主线程中的哦，呵呵，
            // 前面看到直接使用了handler对象，是不是在找，在什么地方实例化的呢？
            // 现在看到了吧？？？呵呵，开始的时候实例化不了，因为该线程的Looper对象
            // 还不存在呢。现在可以实例化了
            // 这里Looper.myLooper()获得的就是该线程的Looper对象了
            mThreadHandler = new ThreadHandler(Looper.myLooper());


            // 这个方法，有疑惑吗？
            // 其实就是一个循环，循环从MessageQueue中取消息。
            // 不经常去看看，你怎么知道你有新消息呢？？？
            Looper.loop();
        }

        // 定义线程类中的消息处理类
        class ThreadHandler extends Handler {
            public ThreadHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                // 这里对该线程中的MessageQueue中的Message进行处理
                // 这里我们再返回给主线程一个消息
                mMainHandler = new MyHandler(Looper.getMainLooper());
                Message msg2 = mMainHandler.obtainMessage(1, 1, 1, "子线程收到:" + (String) msg.obj);
                mMainHandler.sendMessage(msg2);
            }
        }
    }
}

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mThreadHandler;

    private final Handler mMainHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 11:
                    Log.d("gg", (String) msg.obj + msg.what);
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        // 启动线程
        new MyThread().start();

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 这里handler的实例化在线程中，不知道何时创建成功，所以在使用前先判断下，否则可能crash
                if (mThreadHandler != null) {
                    mThreadHandler.obtainMessage(1, "主线程发送的消息").sendToTarget();
                }
            }
        });
    }

    class MyThread extends Thread {

        @Override
        public void run() {
            Looper.prepare(); // 创建该线程的Looper对象，用于接收消息

            // 注意了：这里的handler是定义在主线程中的哦，呵呵，
            // 前面看到直接使用了handler对象，是不是在找，在什么地方实例化的呢？
            // 现在看到了吧？？？呵呵，开始的时候实例化不了，因为该线程的Looper对象还不存在呢。现在可以实例化了
            // 这里Looper.myLooper()获得的就是该线程的Looper对象了
            mThreadHandler = new ThreadHandler(Looper.myLooper());

            // 这个方法，有疑惑吗？
            // 其实就是一个循环，循环从MessageQueue中取消息。
            // 不经常去看看，你怎么知道你有新消息呢？？？
            Looper.loop();
        }

        // 定义线程类中的消息处理类
        class ThreadHandler extends Handler {

            public ThreadHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                // 这里对该线程中的MessageQueue中的Message进行处理
                // 这里我们再返回给主线程一个消息
                switch (msg.what) {
                    case 1:
                        Log.d("gg", (String) msg.obj + msg.what);
                        mMainHandler.obtainMessage(11, "子线程收到:" + (String) msg.obj).sendToTarget();
                        break;
                }

            }
        }
    }
}
// 09-02 16:30:10.658: D/gg(7800): 主线程发送的消息1
// 09-02 16:30:10.658: D/gg(7800): 子线程收到:主线程发送的消息11

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mThreadHandler;

    private final Handler mMainHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 11:
                    Log.d("gg", (String) msg.obj + msg.what);
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    };

    // 定义线程类中的消息处理类
    class ThreadHandler extends Handler {

        public ThreadHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            // 这里对该线程中的MessageQueue中的Message进行处理
            // 这里我们再返回给主线程一个消息
            switch (msg.what) {
                case 1:
                    Log.d("gg", (String) msg.obj + msg.what);
                    mMainHandler.obtainMessage(11, "子线程收到:" + (String) msg.obj).sendToTarget();
                    break;
            }
        }
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        HandlerThread handlerThread = new HandlerThread("xiancheng");
        handlerThread.start();
        mThreadHandler = new ThreadHandler(handlerThread.getLooper());

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 这里handler的实例化在线程中，不知道何时创建成功，所以在使用前先判断下，否则可能crash
                if (mThreadHandler != null) {
                    mThreadHandler.obtainMessage(1, "主线程发送的消息").sendToTarget();
                }
            }
        });
    }
}

4、其他线程给自己发送Message 

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mThreadHandler;
    private Handler mMainHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 启动线程
                new MyThread().start();
            }
        });
    }

    class MyHandler extends Handler {

        public MyHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            mText.setText((String) msg.obj);
        }
    }

    class MyThread extends Thread {

        @Override
        public void run() {
            Looper.prepare(); // 创建该线程的Looper对象
            // 这里Looper.myLooper()获得的就是该线程的Looper对象了
            mThreadHandler = new ThreadHandler(Looper.myLooper());
            Message msg = mThreadHandler.obtainMessage(1, "我自己");
            mThreadHandler.sendMessage(msg);

            Looper.loop();
        }

        // 定义线程类中的消息处理类
        class ThreadHandler extends Handler {

            public ThreadHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                // 这里对该线程中的MessageQueue中的Message进行处理
                // 这里我们再返回给主线程一个消息
                // 加入判断看看是不是该线程自己发的信息
                if (msg.what == 1) {
                    mMainHandler = new MyHandler(Looper.getMainLooper());
                    Message msg2 = mMainHandler.obtainMessage(1, "禀告主线程:我收到了自己发给自己的Message");
                    mMainHandler.sendMessage(msg2);
                }
            }
        }
    }
}

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mHandler;
    private Handler mMainHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);
        mBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View arg0) {
                // 启动线程
                new MyThread().start();
            }
        });
    }

    class MainHandler extends Handler {
        public MainHandler(Looper looper) {
            super(looper);
        }
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 11:
                    Log.d("gg", (String) msg.obj + msg.what);
                    mText.setText((String) msg.obj);
                    break;
            }
        }
    }

    class MyThread extends Thread {
        @Override
        public void run() {
            Looper.prepare(); // 创建该线程的Looper对象
            // 这里Looper.myLooper()获得的就是该线程的Looper对象了
            // Looper looper = Looper.getMainLooper();
            // Looper looper2 = Looper.myLooper(); // looper2 != looper
            mHandler = new ThreadHandler(Looper.myLooper());
            mHandler.obtainMessage(1, 2, 3, "我自己").sendToTarget();
            Looper.loop();
        }

        // 定义线程类中的消息处理类
        class ThreadHandler extends Handler {

            public ThreadHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                // 这里对该线程中的MessageQueue中的Message进行处理
                // 这里我们再返回给主线程一个消息
                // 加入判断看看是不是该线程自己发的信息
                switch (msg.what) {
                    case 1:
                        Log.d("gg", (String) msg.obj + msg.what);
                        mMainHandler = new MainHandler(Looper.getMainLooper());
                        mMainHandler.obtainMessage(11, 22, 33, "禀告主线程:我收到了自己发给自己的Message").sendToTarget();
                        break;
                }
            }
        }
    }
}
// 09-02 16:06:42.322: D/gg(7001): 我自己1
// 09-02 16:06:42.338: D/gg(7001): 禀告主线程:我收到了自己发给自己的Message11

class LooperThread extends Thread {
    public Handler mHandler;

    @Override
    public void run() {
        Looper.prepare();

        mHandler = new Handler() {

            @Override
            public void handleMessage(Message msg) {

            }
        };

        Looper.loop();
    }
}


//通过Handler启动线程    
HandlerThread handlerThread = new HandlerThread("threadone");  
handlerThread.start();  
mHandler =  new Handler(handlerThread.getLooper());//那么这个Handler对象就是与HandlerThread这个线程绑定了（这时就不再是与UI线程绑定了，这样它处理耗时操作将不会阻塞UI）
mHandler.post(mRunnable);    

private Runnable mRunnable = new Runnable() {   
	@Override
	public void run() {    
		count++;    
		//setTitle("" +count);    
		//每2秒执行一次    
		mHandler.postDelayed(mRunnable, 2000);    
    }    
};

是MessageQueue的管理者。

每一个MessageQueue都不能脱离Looper而存在，Looper对象的创建是通过prepare()函数来实现的。同时每一个Looper对象和一个线程关联。
通过调用Looper.myLooper()可以获得当前线程的Looper对象
创建一个Looper对象时，会同时创建一个MessageQueue对象。除了主线程有默认的Looper，其他线程默认是没有MessageQueue对象的，所以，不能
接受Message。
如需要接受，自己定义一个Looper对象(通过prepare函数),这样该线程就有了自己的Looper对象和MessageQueue数据结构了。
Looper从MessageQueue中取出Message然后，交由Handler的handleMessage进行处理。处理完成后，调用Message.recycle()将其放入Message Pool中。

http://www.eoeandroid.com/thread-49595-1-1.html?_dsign=7a783b06


Android 之 Looper、MessageQueue、Handler 与消息循环

Handler主要用来发送消息和处理消息。每个handler实例都对应着一个线程和该线程的消息队列。
当你创建一个handler对象时，该handler对象就属于创建它的线程，并和该线程的消息队列绑定，比如在主线程中创建handler对象，那么该handler就只属于主线程，并且和主线程的消息队列绑定。








dcking
关注
详解Android中Handler的使用方法
01-04
在Android开发中，我们经常会遇到这样一种情况：在UI界面上进行某项操作后要执行一段很耗时的代码，比如我们在界面上点击了一个”下载“按钮，那么我们需要执行网络请求，这是一个耗时操作，因为不知道什么时候才能...
Android中Handler与Message的简单实例
08-29
首先，我们需要定义一个Handler，然後在Handler中重写handleMessage()方法。在handleMessage()方法中，我们可以对消息进行处理，并更新UI组件的内容。 在这个示例中，我们使用Button来触发Handler的sendMessage()...
Android基础篇 Handler
圈池
06-01 1227
一、Handler作用 1）传递消息Message Message 的构造函数是公共的，但获得其中之一的最佳方法是调用Message.obtain()或Handler.obtainMessage()方法之一，这将从回收对象池中提取它们 //1.通过handler实例获取 Handler handler = new Handler(); Message message = handler.obtainMessage(); //源码 ：第一种获取方式其实也是内部调用了第二种 public final Me
Handler发送的消息通过obtain获取
私房菜
07-29 1697
话说在工作中第一次接触android 的Handler 的时候，不知道怎么去关注性能。这样使用并不是一定不允许，但是目前任何产品对于性能的要求越来越高，任何内存、调度的优化都是推荐的、可取的。
Android之Handler分析与理解
ChenYiRan123456的博客
07-03 861
Android中的Handler是一个用于处理消息和线程间通信的机制。它可以将Runnable对象或Message对象发送到特定的线程中进行处理。使用Handler的主要目的是在不同的线程之间进行通信，特别是在后台线程中执行一些任务后，将结果发送到UI线程进行更新。
Android Handler详解
u010636574的专栏
11-13 453
Android应用开发经常要进行网络操作，我们可采用AsyncTask和   Thread+Handler机制来实现  ，今天先总结   Thread+Handler  的使用方法，我们将网络操作放在Thread中，开发的时候要注意这一点，因为在Android2.3里面在网速给力的情况下，是不会出现anr异常的，but，在Android4.0往后所有的网络操作都必须放在线程或者异步任务里面，否则汇
new Handler().obtainMessage().sendToTarget()过程分析
热门推荐
Loader's Blog
03-30 1万+
new Handler().obtainMessage().sendToTarget()这句话用着真爽，一行代码就能搞定异步消息了！所以在代码中使用的算是非常频繁的了，那这又是一个什么样的过程呢？ 这个过程中又有什么玄机呢？ 这篇文章，我们来一步步的分析一下这三句话。 1、new Handler()的分析 new Handler()会辗转来到public Handler(Callb
Android 中Handler引起的内存泄露
09-01
如果Handler是Activity的一个成员变量，并且我们在Handler中安排了未来的消息（例如通过`postDelayed()`），即使Activity已经结束，这些消息仍然会存在于消息队列中，因为它们持有Handler的引用。由于Handler又持有...
android 中Handler 的几种写法
08-06
在Android开发中，`Handler`是一个至关重要的组件，它用于在主线程中处理来自其他线程的消息，确保UI更新和事件处理的同步性。本文将详细介绍`Handler`的几种常见写法，以及如何使用`Handler.Callback`进行消息处理...
Android中Handler引起的内存泄露问题解决办法
09-03
如果我们在Handler中安排了一个延迟的任务，例如使用`postDelayed()`方法，这个任务将在未来的某个时刻被主线程处理，即使Activity已经finish()，Handler仍然持有Activity的引用，阻止了Activity被垃圾回收器清理。...
关于android中obtainMessage()的小疑惑
junice_lee的博客
01-19 1594
今天写代码的时候遇到一个问题：从线程中获取消息….项目中有一段代码handler.obtainMessage(msg)，即从线程中获取一个消息，查看了下源码在handler.obtainMessage()中是这样写的Message android.os.handler.obtainMessage(int what,int arg1,int arg2,Object obj);what: value
Android studio new Message与mHandler.obtainMessage的区别
最新发布
谁呛我名字的博客
04-08 513
和的主要区别在于它们的内存管理策略。总是创建一个新的对象，而则尝试从消息池中获取一个可重用的对象。在大多数情况下，使用是一个更好的选择，因为它有助于减少内存分配和GC压力。
android中Handler中的obtainMessage()
weixin_30917213的博客
09-06 414
public final Message obtainMessage (int what, int arg1, int arg2, Object obj)这里面的4个参数求解释啊。。。byte[] buffer = new byte[1024]; int bytes;bytes = mmInStream.read(buffer);mHandler.obtainMessage(...
Android handler.obtainMessage()传字符串用法
Android系统攻城狮
01-19 8091
1.使用Thread线程实现Runnable的方式 public class MainActivity extends Activity implements Runnable  {   private TextView tv;   Thread mthread;   Message message;   @Override   protected void onCreate(Bundle s...
Handler使用的那些事儿
不为博学，只为休闲
03-24 686
对任何有开发经验的童鞋，对Handler肯定是如雷贯耳，使用也必定非常熟练，当现在我还是想对其来个梳理，总结下常见的疑问：  1.常听人说mHandler.obtainMessage(what,obj).sendToTarget()要比{Message msg = new Message；msg.what= 1;msg.obj = obj;mHandler.sendMessage(msg)}要简
Android源码分析----------Handler消息机制(1)Handler获取Message对象及Message的复用
newone_helloworld的博客
09-03 2146
在研究源码之前,我们对Handler的了解一般是这样的概念:在主线程中,有消息队列Looper,里面有很多的消息,还有一个Handler,用来向Looper发送消息,Looper会将消息接收,不停的取出新消息,并把消息分配给Handler执行,同时,Handler从回收的消息队列中(Message.obtain())获取消息进行复用,再发出新消息,这就构成了Handler的消息机制.现在,我们就来...
Android---探究Handler消息机制
a644388262的博客
07-10 330
在开发Android应用程序的过程中，如果耗时的操作放在Activity的主线程(UI线程)中执行的话，超过五秒钟的时候，就会出现传说中的ANR(Application Not Responsding)，即应用无响应。用户可以选择“等待”而让程序继续运行，也可以选择“强制关闭”。所以一个流畅的合理的应用程序中不能出现ANR。 所以在进行一些耗时操作的时候，我们应该放在子线程中去完成的，完成之后如果我们要更新主线程中的UI视图的话，就要用到Handler了，因为Android系统是禁止在子线程中去更新UI视图
Android handler.obtainMessage()
weixin_33890526的博客
01-29 573
在handler.obtainMessage()的参数是这样写的: Message android.os.Handler.obtainMessage(int what, int arg1, int arg2, Object obj) public final Message obtainMessage (int what, int arg1, int arg2, Object obj)...
Android中Handler消息机制
yinianzhijian99的专栏
01-08 995
Android中Handler消息机制
Android中Handler
05-27
在Android中，Handler是一种用于实现线程之间通信的机制。使用Handler可以让你在主线程中处理后台线程的任务和更新UI界面。 Handler的主要作用是将Runnable或Message对象发送到MessageQueue中，然后Looper循环在MessageQueue中取出这些消息并处理。在Android中，UI线程就是一个Looper，因此可以通过Handler在UI线程中更新UI界面。 使用Handler一般需要以下步骤： 1. 创建Handler对象：可以在主线程中创建，也可以在子线程中创建。 2. 实现Runnable或Message对象：Runnable对象是一段可以在后台线程中执行的代码，Message对象包含了一些信息，可以在主线程中处理。 3. 将Runnable或Message对象发送到MessageQueue中：使用Handler的post方法将Runnable或Message对象发送到MessageQueue中。 4. 在主线程中处理Runnable或Message对象：当MessageQueue中有消息时，Looper循环会在主线程中处理这些消息。 需要注意的是，在使用Handler时要避免在主线程中执行耗时操作，因为这会导致UI线程卡顿。可以将耗时操作放到子线程中执行，然后使用Handler在主线程中更新UI界面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值