精华内容
下载资源
问答
  • Handler泄漏处理

    2019-01-22 05:56:32
    Handler泄露处理: public class BaseHandler<T> extends Handler { WeakReference<T> wr; //弱引用 BaseHandler.BaseHandlerCallBack callBack; public BaseHandler(T t,...

    Handler的泄露处理:

    public class BaseHandler<T> extends Handler {
        WeakReference<T> wr;     //弱引用
        BaseHandler.BaseHandlerCallBack callBack;
    
        public BaseHandler(T t,BaseHandler.BaseHandlerCallBack callBack){
            wr = new WeakReference<T>(t);
            AppLog.LOGE("Handler0:" + t);
            AppLog.LOGE("Handler1:" + wr);
            this.callBack = callBack;
        }
    
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            T t = wr.get();//如果此方法为空, 那么说明wr指向的对象已经被回收了.
            AppLog.LOGE("Handler:" + t);
            if(t != null){
                callBack.callBack(msg);
            }
        }
    
        public interface BaseHandlerCallBack {
            /**
             * 提供的BaseHandler的callback返回接口
             * @param msg  传递的Message信息
             */
            void callBack(Message msg);
        }
    }
    复制代码

    引用:

    private Handler handler = new BaseHandler<>(UpLoadService.class, new BaseHandler.BaseHandlerCallBack() {
            @Override
            public void callBack(Message msg) {
               //do something
            }
        });
    复制代码
    展开全文
  • Android Handler泄露问题

    2016-05-30 14:23:57
    最典型的场景是Handler导致的Activity泄漏,如果Handler中有延迟的任务或者是等待执行的任务队列过长,都有可能因为Handler继续执行而导致Activity发生泄漏。此时的引用关系链是Looper -> MessageQueue -> Message -...
      • 内部类引用导致Activity的泄漏:

        • 最典型的场景是Handler导致的Activity泄漏,如果Handler中有延迟的任务或者是等待执行的任务队列过长,都有可能因为Handler继续执行而导致Activity发生泄漏。此时的引用关系链是Looper -> MessageQueue -> Message -> Handler -> Activity。为了解决这个问题,可以在UI退出之前,执行remove Handler消息队列中的消息与runnable对象。或者是使用Static + WeakReference的方式来达到断开Handler与Activity之间存在引用关系的目的。
      • Activity Context被传递到其他实例中,这可能导致自身被引用而发生泄漏:

        • 内部类引起的泄漏不仅仅会发生在Activity上,其他任何内部类出现的地方,都需要特别留意!我们可以考虑尽量使用static类型的内部类,同时使用WeakReference的机制来避免因为互相引用而出现的泄露。
    • 考虑使用Application Context而不是Activity Context;
    • 解决办法:
      package com.example.jiangwei18.myapplication;
      
      import android.animation.ObjectAnimator;
      import android.animation.TypeEvaluator;
      import android.app.Activity;
      import android.os.Bundle;
      import android.os.Handler;
      import android.os.Message;
      import android.view.animation.Interpolator;
      import android.widget.Button;
      import android.widget.ListView;
      import android.widget.Toast;
      
      import java.lang.ref.WeakReference;
      
      public class MainActivity extends Activity {
          private ListView lv;
          private final MyHandler handler = new MyHandler(this);;
          @Override
          protected void onCreate(Bundle savedInstanceState) {
              super.onCreate(savedInstanceState);
              setContentView(R.layout.activity_main);
              handler.sendEmptyMessageDelayed(0, 4000);
          }
        public static class MyHandler extends Handler{
            WeakReference<MainActivity> mActivity;
            public MyHandler(MainActivity activity){
                 mActivity = new WeakReference<>(activity);
            }
      
            @Override
            public void handleMessage(Message msg) {
                MainActivity mainActivity = mActivity.get();
                Toast.makeText(mainActivity, "hello", Toast.LENGTH_LONG).show();
                super.handleMessage(msg);
            }
        }
      
          @Override
          protected void onDestroy() {
              handler.removeCallbacksAndMessages(null);
              super.onDestroy();
          }
      }
    • (1)static+WeakReference方式 
    • (2)
       /**
           * Remove any pending posts of callbacks and sent messages whose
           * <var>obj</var> is <var>token</var>.  If <var>token</var> is null,
           * all callbacks and messages will be removed.
           */
          public final void removeCallbacksAndMessages(Object token) {
              mQueue.removeCallbacksAndMessages(this, token);
          }

    展开全文
  • 泄漏原因: 长生命周期对象持有短生命周期对象引用,导致该gc的对象无法释放。(非静态内部类和匿名内部类默认会持有外部类的引用) 解决方案 通过程序逻辑来进行保护 1.在关闭Activity的时候停掉你的后台线程。...

    泄漏原因:

    • 长生命周期对象持有短生命周期对象引用,导致该gc的对象无法释放。(非静态内部类和匿名内部类默认会持有外部类的引用)

    解决方案

    • 通过程序逻辑来进行保护
      1.在关闭Activity的时候停掉你的后台线程。线程停掉了,就相当于切断了Handler和外部连接的线,Activity自然会在合适的时候被回收。
      2.如果你的Handler是被Delay的Message持有了引用,那么使用相应的Handler的handler.removeCallbacksAndMessages(null)方法,把消息对象从消息队列移除就行了。
    /**
         * Remove any pending posts of callbacks and sent messages whose
         * <var>obj</var> is <var>token</var>.  If <var>token</var> is null,
         * all callbacks and messages will be removed.
         */
        public final void removeCallbacksAndMessages(Object token) {
            mQueue.removeCallbacksAndMessages(this, token);
        }
    
    • 将Handler声明为静态内部类(静态内部类不持有外部类的引用)
    
    private static class MyHandler extends Handler {
        WeakReference<Activity > mActivityReference;
        MyHandler(Activity activity) {
            mActivityReference= new WeakReference<Activity>(activity);
        }
     
        @Override
        public void handleMessage(Message msg) {
            final Activity activity = mActivityReference.get();
            if (activity != null) {//一定要盘空,防止弱引用对象被gc
                mImageView.setImageBitmap(mBitmap);
            }
        }
    
    
    展开全文
  • 泄漏原因:长生命周期对象持有短生命周期对象引用,导致该gc的对象无法释放。(非静态内部类和匿名内部类默认会持有外部类的引用)解决方案通过程序逻辑来进行保护1.在关闭Activity的时候停掉你的后台线程。线程停掉了...

    泄漏原因:

    长生命周期对象持有短生命周期对象引用,导致该gc的对象无法释放。(非静态内部类和匿名内部类默认会持有外部类的引用)

    解决方案

    通过程序逻辑来进行保护

    1.在关闭Activity的时候停掉你的后台线程。线程停掉了,就相当于切断了Handler和外部连接的线,Activity自然会在合适的时候被回收。

    2.如果你的Handler是被Delay的Message持有了引用,那么使用相应的Handler的handler.removeCallbacksAndMessages(null)方法,把消息对象从消息队列移除就行了。

    /**

    * Remove any pending posts of callbacks and sent messages whose

    * obj is token. If token is null,

    * all callbacks and messages will be removed.

    */

    public final void removeCallbacksAndMessages(Object token) {

    mQueue.removeCallbacksAndMessages(this, token);

    }

    将Handler声明为静态内部类(静态内部类不持有外部类的引用)

    private static class MyHandler extends Handler {

    WeakReference mActivityReference;

    MyHandler(Activity activity) {

    mActivityReference= new WeakReference(activity);

    }

    @Override

    public void handleMessage(Message msg) {

    final Activity activity = mActivityReference.get();

    if (activity != null) {//一定要盘空,防止弱引用对象被gc

    mImageView.setImageBitmap(mBitmap);

    }

    }

    展开全文
  • 非静态Handler可能导致泄漏,这也是讨论很久了,我想问的不是这个,而是解决方案中,基本都是说通过声明为静态的,完后里面用弱引用来对外部的activity来进行引用,这样就不影响外部的activity被回收,网上随便找的...
  • Handler内存泄漏

    2019-09-12 17:24:56
    handler之所以造成内存泄漏是因为handler执有短周期对象引用,在所引用对象周期结束时,handler还有为执行任务,导致所应用的对象无法被系统回收。 一般出现在activity使用handler时,定义一个内部类handler,...
  • Android Handler 泄漏

    2020-09-02 11:44:24
    Android Handler泄漏: 1.新建匿名Handler内部类,默认引用外部的Activity 2.new Handler实例,实例内部会引用当前线程(主线程)绑定的Looper,以及该Looper内部的MessageQueue, 3.发送Message的时候,会发送到...
  • Android 解决handler内存泄露的方法

    千次阅读 2019-02-19 18:41:34
    文章目录1、简介2、方法一避免Handler 泄露3、方法二添加弱连接 1、简介 大体理解为: Handler 在使用的时候一般要依附于一个对象,很多时候 handler 延时发送的时候 ,所依附的对象得不到释放,于是出现了 handler ...
  • handler内存泄漏

    2017-09-22 14:04:00
    handler内存泄漏原因有两个: 第一: public final Handler handler = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage(msg); }};@Overrideprotected void onCreate(B...
  • handler 内存泄漏

    2018-02-09 20:12:36
    Handler 消息机制用于主线程和子线程...使用率非常高,然而handler存在着内存泄漏。通常大家的写法是如下public class TestActivity extends Activity { .......  Handler handler = new Handler(){ @Override ...
  • 防止handler内存泄漏

    2016-05-21 13:54:00
    handler为什么会内存泄漏呢,handler是个内部类,内部类会持有外部类的引用,内部类需要依赖外部类。handler需要定义为静态类,当你推出Activity,handler还在工作, 下面是引起内存溢出的:Activity已经finish,但...
  • handler内存泄露

    2016-09-03 20:21:13
    Handler 内部类持有 外部类Activity的引用,如果Activity退出而Handler还有延迟处理的消息没有处理完,会导致Activity不能回收,反复如此会导致内存泄露。 解决方案一: onDestroy时清除消息,mHandler....
  • Handler 内存泄漏

    2019-07-13 21:39:22
    内存泄漏 当系统运行到某一时刻,某些占用着一定内存空间的操作或对象在之后都不会使用了,所以此时系统理应将这些内存空间给释放掉给接下来的系统运行使用,但是因为一些特殊的原因,从而导致这部分的内存空间一直...
  • handler的内存泄漏

    2016-09-17 23:09:52
    handler的内存泄漏
  • Android Handler内存泄漏

    2017-01-18 14:58:19
    Handler是Android常用的工具,但是使用不当容易引起内存泄漏泄漏的原因是:当Handler声明为非静态(匿名)内部类,外部引用Activity时,会组织GC回收Activity。
  • 发现handler有内存泄漏,但是度娘的那些静态类自定义handler并没有解决问题,并且那种方式局限性很严重。然后我用现在的这种方式完全解决内存泄漏问题。人格担保有用,不行就喷我。 前言 因为Android采取了单线程...
  • 1. 说Handler内存泄露这种文章挺多的,基本就是handler 使用不当 持有外部引用导致的内存泄露完毕. 2.根据可达性gc 算法,当一个引用没有被root 对象引用时,该对象内存随时被系统回收,那么handler 的引用链又是...
  • Handler内存泄漏问题

    2019-06-14 11:06:58
    在activity中使用匿名内部类方式使用handler时会造成内存泄漏 private Handler handler = new Handler() { public void handleMessage(android.os.Message msg)  { //doSomething() } }; 解决方式 使用...
  • 那么消息队列的消息依旧会由handler进行处理,若此时handler声明为内部类(非静态内部类),我们知道内部类天然持有外部类的实例引用,那么就会导致activity无法回收,进而导致activity泄露。 二、Handler内存泄漏...
  • Handler内存泄露

    2016-01-12 15:58:10
    使用Handler造成内存泄露的原因: 当使用内部类(包括匿名类)来创建Handler的时候,Handler对象会隐式地持有一个外部类对象(通常是一个Activity)的引用(不然你怎么可能通过Handler来操作Activity中的View?)...
  • Android Handler 内存泄露

    2016-01-23 20:09:55
    内存泄露:java中的垃圾(GC),垃圾回收的机制受java虚拟机的控制。java虚拟机会不定时的执行 System.gc(); 一个本该被回收的对象A,被一个生命周期还没有完成的对象B所持有,导致该被回收的对象A无法被回收。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,839
精华内容 17,135
关键字:

handler泄露