4d3bf4cac28c
4d3bf4cac28c

LeakCanary源码解析

LeakCanary源码解析

前言

对于内存泄漏的检测，基于MAT起点较高，所以一般我们都使用LeakCanary来作为我们的内存泄漏检测工具来使用。

基础知识

四种引用

LeakCanary主要是基于弱引用来进行对于已经销毁的Activity和Fragment的回收监控来实现的。

  • 强引用：无论如何都不会回收。

  • 软引用：内存足够不回收。内存不够时，就会回收。

  • 弱引用：垃圾回收时直接回收，则直接回收。

  • 虚引用：垃圾回收时直接回收。

引用队列（ReferenceQueue）。

软引用和弱引用都可以关联一个引用队列。当引用的对象被回收以后，会将软引用加入到与之关联的引用队列中。LeakCanary的基础实现就是将已经销毁的Activity和Fragment所对应的实例放入到弱引用中，并关联一个引用队列。如果实例进行了回收，那么弱引用就会放入到ReferenceQueue中，如果一段时间后，所监控的实例还未在ReferenceQueue中出现，那么可以证明出现了内存泄漏导致了实例没有被回收。

使用方法

配置：

dependencies {
  debugImplementation 'com.squareup.leakcanary:leakcanary-android:1.6.3'
  releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.3'
  // Optional, if you use support library fragments:
  debugImplementation 'com.squareup.leakcanary:leakcanary-support-fragment:1.6.3'
}

使用：

public class ExampleApplication extends Application {
  @Override public void onCreate() {
    super.onCreate();
    LeakCanary.install(this);
  }
}

Leakcanary原理解析

从程序的唯一入口来进行分析。本文是基于1.6.3版本来进行源码解析的。对应的解析源码地址为leakcanary-source。

注册实例的监控

    public static @NonNull RefWatcher install(@NonNull Application application) {
        return refWatcher(application)//创建一个Android端使用的引用监控的构造者
                .listenerServiceClass(DisplayLeakService.class)
                //设置不进行监控的类引用对象
                .excludedRefs(AndroidExcludedRefs.createAppDefaults().build())
                //创建对于引用的监控
                .buildAndInstall();
    }

这个方法比较简短，一个个进行解析吧。

构造一个AndroidRefWatcherBuilder对象
//创建一个AndroidRefWatcherBuilder对象   
public static @NonNull AndroidRefWatcherBuilder refWatcher(@NonNull Context context) {   
    return new AndroidRefWatcherBuilder(context);   
}

这里创建的AndroidRefWatcherBuilder对象是一个适用于Android端的引用监控的构造者。

设置后台的监听类
  //AndroidRefWatcherBuilder.java
  //设置一个类用来监听分析的结果。
  public @NonNull AndroidRefWatcherBuilder listenerServiceClass(@NonNull Class listenerServiceClass) {
    enableDisplayLeakActivity = DisplayLeakService.class.isAssignableFrom(listenerServiceClass);
    //设置一个监听者
    return heapDumpListener(new ServiceHeapDumpListener(context, listenerServiceClass));
  }

  //RefWatcherBuilder.java
  //HeapDump的监听者
  public final T heapDumpListener(HeapDump.Listener heapDumpListener) {
    this.heapDumpListener = heapDumpListener;
    return self();
  }

这里将DisplayLeakService类作为了我们最终内存泄漏的分析者，并且该类能够进行内存泄漏消息的通知（一般是Notification）。

不纳入监控的引用

excludedRefs方法能够将一些我们不关心的引用排除在我们的监控范围以外。这里这么处理，主要是因为一些系统级别的引用问题。我们可以具体看一下里面有哪些东西是我们不需要关注的。

    //由于Android的AOSP本身可能会存在内存泄漏的东西，所以对于这些东西默认是不会进行提醒的。
    public static @NonNull ExcludedRefs.Builder createAppDefaults() {
        //将AndroidExcludedRefs所有的枚举类型都考虑在内。
        return createBuilder(EnumSet.allOf(AndroidExcludedRefs.class));
    }

    public static @NonNull ExcludedRefs.Builder createBuilder(EnumSet refs) {
        ExcludedRefs.Builder excluded = ExcludedRefs.builder();
        //遍历所有的枚举类型
        for (AndroidExcludedRefs ref : refs) {
            //如果枚举类型执行引用的排除处理
            if (ref.applies) {
                //调用枚举的add方法，这里面会将所有需要排除的引用类都放到出入的excluede中
                ref.add(excluded);
                ((ExcludedRefs.BuilderWithParams) excluded).named(ref.name());
            }
        }
        return excluded;
    }

这个可能会有一些难以理解，我们先简单分析一下AndroidExcludedRefs这个类。

public enum AndroidExcludedRefs {
    //参数，标识是否需要执行add方法
    final boolean applies;
    AndroidExcludedRefs() {
        this(true);
    }
    AndroidExcludedRefs(boolean applies) {
        this.applies = applies;
    }
    //枚举类需要实现的方法
    abstract void add(ExcludedRefs.Builder excluded);
}

AndroidExcludedRefs是一个枚举类型。含有成员变量applies以及add()方法。

我们再分析一个具体的枚举类型。

//AndroidExcludedRefs.java
    ACTIVITY_CLIENT_RECORD__NEXT_IDLE(SDK_INT >= KITKAT && SDK_INT <= LOLLIPOP) {
        @Override
        void add(ExcludedRefs.Builder excluded) {
            //设置排除的类中的某个属性
            excluded.instanceField("android.app.ActivityThread$ActivityClientRecord", "nextIdle")
                    //设置排除的原因
                    .reason("Android AOSP sometimes keeps a reference to a destroyed activity as a"
                            + " nextIdle client record in the android.app.ActivityThread.mActivities map."
                            + " Not sure what's going on there, input welcome.");
        }
    },

ACTIVITY_CLIENT_RECORD__NEXT_IDLE就是一个具体的枚举类型。applies赋值为SDK_INT >= KITKAT && SDK_INT <= LOLLIPOP。也有add方法的具体实现。实现中将需要排除的引用类型添加到了excluded中。

所以当我们的系统版本号满足SDK_INT >= KITKAT && SDK_INT <= LOLLIPOP这个条件的时候，就会执行add方法。

AndroidExcludedRefs具有不同的枚举实例，会根据不同的系统版本来进行不同的处理。这里其实主要是保证对于一些系统级别的内存泄漏情况不再进行提示。

创建引用的监控

我们直接看看buildAndInstall中是如何对已经执行onDestroy的Activity进行监控的。

  //根据对应的设置信息，返回一个RefWatcher对象
  public @NonNull RefWatcher buildAndInstall() {
    if (LeakCanaryInternals.installedRefWatcher != null) {
      throw new UnsupportedOperationException("buildAndInstall() should only be called once.");
    }
    //通过构造者模式中的build()方法创建一个RefWatcher对象,这里面会有很多默认的设置
    RefWatcher refWatcher = build();
    if (refWatcher != DISABLED) {
      //如果允许显示内存泄漏Activity，则进行处理
      if (enableDisplayLeakActivity) {
        LeakCanaryInternals.setEnabledAsync(context, DisplayLeakActivity.class, true);
      }
      //如果设置了监听Activity，那么就为Activity注册生命周期监听
      if (watchActivities) {
        ActivityRefWatcher.install(context, refWatcher);
      }
      //如果设置了监听Fragment，那么就为Fragment注册生命周期监听
      if (watchFragments) {
        FragmentRefWatcher.Helper.install(context, refWatcher);
      }
    }
    LeakCanaryInternals.installedRefWatcher = refWatcher;
    return refWatcher;
  }

我们这里主要看一下如何进行Activity以及Fragment的监听的。

  1. 对Activity的处理
    //ActivityRefWatcher.java
    public static void install(@NonNull Context context, @NonNull RefWatcher refWatcher) {
        Application application = (Application) context.getApplicationContext();
        //创建一个对于Activity的弱引用监听类
        ActivityRefWatcher activityRefWatcher = new ActivityRefWatcher(application, refWatcher);
        //对传入的应用的Application注册一个对于Activity的生命周期监听函数
        application.registerActivityLifecycleCallbacks(activityRefWatcher.lifecycleCallbacks);
    }

这里创建了一个ActivityRefWatcher对象，然后将对于应用，通过registerActivityLifecycleCallbacks注册了一个监听的回调。

    //ActivityRefWatcher.java
    private final Application.ActivityLifecycleCallbacks lifecycleCallbacks =
            new ActivityLifecycleCallbacksAdapter() {
                //只监听destory方法，将调用destory的activity添加到监听watcher中
                @Override
                public void onActivityDestroyed(Activity activity) {
                    refWatcher.watch(activity);
                }
            };

在这个监听方法中，只监听了Activity的onDestroy方法。当Activity销毁的时候，使用refWatcher来监控其实例。

  1. 对Fragment的处理
//FragmentRefWatcher.java
    public static void install(Context context, RefWatcher refWatcher) {
            List fragmentRefWatchers = new ArrayList<>();
            //将实现了FragmentRefWatcher接口的两个实现类加入到fragmentRefWatchers中
            //两个实现类，一个是实现对于V4包下的Fragment的监听，一个是对于当前包下Fragment的监听
            if (SDK_INT >= O) {
                //实现类AndroidOFragmentRefWatcher
                fragmentRefWatchers.add(new AndroidOFragmentRefWatcher(refWatcher));
            }

            try {
                //实现类SupportFragmentRefWatcher用于监听V4包下面的Fragment
                //这里使用反射，是因为SupportFragmentRefWatcher这个类在support-fragment这个module中。
                //所以，如果我们没有引入V4的话，其实这个类是可以不引入的。
                Class fragmentRefWatcherClass = Class.forName(SUPPORT_FRAGMENT_REF_WATCHER_CLASS_NAME);
                Constructor constructor = fragmentRefWatcherClass.getDeclaredConstructor(RefWatcher.class);
                FragmentRefWatcher supportFragmentRefWatcher = (FragmentRefWatcher) constructor.newInstance(refWatcher);
                fragmentRefWatchers.add(supportFragmentRefWatcher);
            } catch (Exception ignored) {
            }
            //如果没有Fragment的监控者，那么直接返回
            if (fragmentRefWatchers.size() == 0) {
                return;
            }
            //创建Helper实例
            Helper helper = new Helper(fragmentRefWatchers);
            Application application = (Application) context.getApplicationContext();
            //注册Activity的生命周期回调
            application.registerActivityLifecycleCallbacks(helper.activityLifecycleCallbacks);
        }

由于我们经常使用的Fragment包含两种，一种是support包中的Fragment，一种是标准的app包中的Fragment。这里对这两种都进行了处理。

我们看一下对于注册的生命周期函数

        private final Application.ActivityLifecycleCallbacks activityLifecycleCallbacks =
                new ActivityLifecycleCallbacksAdapter() {
                    @Override
                    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                        for (FragmentRefWatcher watcher : fragmentRefWatchers) {
                            //这里会调用具体的实现类的watchFragments方法。这里关心的是绑定的Activity的onCreate方法。走到这里的时候已经创建了对应FragmentManager对象
                            //而通过FragmentManager对象可以来registerFragmentLifecycleCallbacks来创建对于其管理的Fragment的生命周期监听
                            watcher.watchFragments(activity);
                        }
                    }
                };

这里我们同样是注册了Activity的生命周期回调。但是这里监控的是onActivityCreated方法。我们这里看一下watchFragments的实现。

具体的实现有两个类，一个是SupportFragmentRefWatcher，一个是AndroidOFragmentRefWatcher。我们这里只分析第一个。剩下的另一个是类似的，只是因为使用的Fragment不同，而有所区别。

    public void watchFragments(Activity activity) {
        //V4包中的Fragment，必须使用FragmentActivity来进行处理
        if (activity instanceof FragmentActivity) {
            FragmentManager supportFragmentManager = ((FragmentActivity) activity).getSupportFragmentManager();
            supportFragmentManager.registerFragmentLifecycleCallbacks(fragmentLifecycleCallbacks, true);
        }
    }

    private final FragmentManager.FragmentLifecycleCallbacks fragmentLifecycleCallbacks =
            new FragmentManager.FragmentLifecycleCallbacks() {

                @Override
                public void onFragmentViewDestroyed(FragmentManager fm, Fragment fragment) {
                    View view = fragment.getView();
                    if (view != null) {
                        //当fragment的view销毁的时候，开始监控
                        refWatcher.watch(view);
                    }
                }

                @Override
                public void onFragmentDestroyed(FragmentManager fm, Fragment fragment) {
                    //当fragment销毁的时候，开始监控
                    refWatcher.watch(fragment);
                }
            };

所以，这里通过获取Activity中的FragmentManager，通过registerFragmentLifecycleCallbacks来对于其管理的Fragment的生命周期进行监听。当Fragment执行销毁的时候，将其引用加入到监控队列。

到这里为止，就已经将我们的Activity和Fragment通过refWatcher的watch进行了监控。

那么我们下一步分析，watch方法中又是如何监控实例，并判断其存在内存泄漏的。

监控

我们对于已经销毁的界面会通过refWatcher的watch方法来进行监控。

//RefWatcher.java
    public void watch(Object watchedReference) {
        //重载方法
        watch(watchedReference, "");
    }
    public void watch(Object watchedReference, String referenceName) {
        if (this == DISABLED) {
            return;
        }
        //保证watch的对象不为空
        checkNotNull(watchedReference, "watchedReference");
        checkNotNull(referenceName, "referenceName");
        final long watchStartNanoTime = System.nanoTime();
        //创建一个UUID
        String key = UUID.randomUUID().toString();
        //将UUID保存到set中
        retainedKeys.add(key);
        //创建一个弱引用，指向要检测的对象。
        //如果这个弱引用被回收，那么会将reference加入到queue队列中
        
        final KeyedWeakReference reference = new KeyedWeakReference(watchedReference, key, referenceName, queue);
        //判断reference是否被回收
        ensureGoneAsync(watchStartNanoTime, reference);
    }

这个里面主要执行了3个操作

  • 创建了UUID
  • 将生成的UUID保存到retainedKeys队列中。
  • 创建一个弱引用，指定了对应的引用队列queue。

这里的retainedKeys队列记录了我们执行了监控的引用对象。而queue中会保存回收的引用。所以通过二者的对比，我们就可以找到内存泄漏的引用了。

我们看一下ensureGoneAsync中是如何执行这个操作过程的。

    //RefWatcher.java
    private void ensureGoneAsync(final long watchStartNanoTime, final KeyedWeakReference reference) {
        watchExecutor.execute(new Retryable() {
            @Override
            public Retryable.Result run() {
                return ensureGone(reference, watchStartNanoTime);
            }
        });
    }

这里的watcheExecute使用的是AndroidWatchExecutor

//AndroidRefWatcherBuilder.java
  @Override protected @NonNull WatchExecutor defaultWatchExecutor() {
    return new AndroidWatchExecutor(DEFAULT_WATCH_DELAY_MILLIS);
  }

我们跟踪一下execute方法。

//AndroidWatchExecutor.java
  @Override public void execute(@NonNull Retryable retryable) {
    //如果当前线程是主线程，则直接执行waitForIdl
    if (Looper.getMainLooper().getThread() == Thread.currentThread()) {
      waitForIdle(retryable, 0);
    } else {
      //如果不是主线程，则通过Handler机制，将waitForIdle放入到主线程去执行
      postWaitForIdle(retryable, 0);
    }
  }

  private void postWaitForIdle(final Retryable retryable, final int failedAttempts) {
    //通过Handler机制，将waitForIdle发送到主线程执行
    mainHandler.post(new Runnable() {
      @Override public void run() {
        waitForIdle(retryable, failedAttempts);
      }
    });
  }

  private void waitForIdle(final Retryable retryable, final int failedAttempts) {
    //当messagequeue闲置时，增加一个处理。这种方法主要是为了提升性能，不会影响我们正常的应用流畅度
    //这个方法会在主线程执行，所以postToBackgroundWithDelay会在主线程执行
    Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
      @Override public boolean queueIdle() {
        postToBackgroundWithDelay(retryable, failedAttempts);
        return false;
      }
    });
  }

所以这里最终都会在主线程中执行postToBackgroundWithDelay方法。

  private void postToBackgroundWithDelay(final Retryable retryable, final int failedAttempts) {
    //计算补偿因子。如果返回了重试的话，这个failedAttempts回增加，会使得方法的执行时间延迟时间增加。
    //比如说第一次，演示5秒执行，但是执行结果为RETRY，那么下一次就是延迟10秒来执行了
    long exponentialBackoffFactor = (long) Math.min(Math.pow(2, failedAttempts), maxBackoffFactor);
    //计算延迟时间
    long delayMillis = initialDelayMillis * exponentialBackoffFactor;
    //backgroundHandler会将run方法中的代码放在一个新的线程中去执行。
    backgroundHandler.postDelayed(new Runnable() {
      @Override public void run() {
        Retryable.Result result = retryable.run();
        if (result == RETRY) {
          postWaitForIdle(retryable, failedAttempts + 1);
        }
      }
    }, delayMillis);
  }

这个方法的执行，会根据执行的次数进行来延迟执行对应的run方法。

我们看一下retryable.run()方法的执行。也就回到了我们的RefWatcher中的ensureGoneAsync方法。

private void ensureGoneAsync(final long watchStartNanoTime, final KeyedWeakReference reference) {
  watchExecutor.execute(new Retryable() {
    @Override public Retryable.Result run() {
      return ensureGone(reference, watchStartNanoTime);
    }
  });
}

这里的ensureGone方法属于我们最核心的代码了。

    //判断reference是否被回收
    @SuppressWarnings("ReferenceEquality")
    // Explicitly checking for named null.
    Retryable.Result ensureGone(final KeyedWeakReference reference, final long watchStartNanoTime) {
        long gcStartNanoTime = System.nanoTime();
        long watchDurationMs = NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);
        //移除已经回收的监控对象
        removeWeaklyReachableReferences();
        //如果当前是debug状态，则直接返回retry
        if (debuggerControl.isDebuggerAttached()) {
            // The debugger can create false leaks.
            return RETRY;
        }
        //监控对象已经回收了，直接返回Done
        if (gone(reference)) {
            return DONE;
        }
        //执行一次垃圾回收
        gcTrigger.runGc();
        //再次移除已经回收的监控对象
        removeWeaklyReachableReferences();
        if (!gone(reference)) {
            //如果仍然没有回收，证明发生了内存泄漏
            long startDumpHeap = System.nanoTime();
            //gc执行的时长
            long gcDurationMs = NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);
            //dump出hprof文件
            File heapDumpFile = heapDumper.dumpHeap();
            if (heapDumpFile == RETRY_LATER) {
                // Could not dump the heap.
                //不能生成快照文件的话，进行重试
                return RETRY;
            }
            //生成hprof文件消耗的的时间
            long heapDumpDurationMs = NANOSECONDS.toMillis(System.nanoTime() - startDumpHeap);
            HeapDump heapDump = heapDumpBuilder.heapDumpFile(heapDumpFile).referenceKey(reference.key)
                    .referenceName(reference.name)
                    .watchDurationMs(watchDurationMs)
                    .gcDurationMs(gcDurationMs)
                    .heapDumpDurationMs(heapDumpDurationMs)
                    .build();
            //分析堆内存，heapdumpListener默认是ServiceHeapDumpListener
            heapdumpListener.analyze(heapDump);
        }
        return DONE;
    }

这段代码执行了几个过程

  1. 移除已经回收的监控对象
  2. 如果当前监控的对象已经回收了，直接返回DONE。
  3. 如果没有回收，则强行执行一次GC操作。
  4. 再次移除已经回收的监控对象。
  5. 如果当前监控对象仍然没有回收，则dump出hprof文件，然后根据快照文件进行内存泄漏情况的分析。

这里我们对每个方法都一一的进行一次分析

移除已回收的弱引用对象
    private void removeWeaklyReachableReferences() {
        KeyedWeakReference ref;
        //循环queue
        while ((ref = (KeyedWeakReference) queue.poll()) != null) {
            //在queue中的ref，说明已经被回收了，所以直接将其对应的key从retainedKeys移除。
            retainedKeys.remove(ref.key);
        }
    }

这里的queue是我们提到的引用队列，而retainedKeys中则保存着我们要监控的对象。当对象被回收以后，就会将对应的弱引用信息保存到queue中，所以我们将queue中的相关弱引用信息从retainedKeys移除。剩下的就是我们在监听或者已经发生内存泄漏的对象了。

判断监控对象是否回收
    //判断监控的对象是否已经回收 true:已经回收
    private boolean gone(KeyedWeakReference reference) {
        return !retainedKeys.contains(reference.key);
    }

在上一步中，我们已经将回收的引用信息从retainedKeys中移除了，所以这里只要通过判断这个set中是否有我们监控的这个类即可。

导出.hprof文件
  public File dumpHeap() {
    //创建一个.hrof文件
    File heapDumpFile = leakDirectoryProvider.newHeapDumpFile();
    if (heapDumpFile == RETRY_LATER) {
      //创建失败了，等会再重试
      return RETRY_LATER;
    }
    FutureResult waitingForToast = new FutureResult<>();
    //通过Handler机制在主线程显示Toast，使用了CountDownLatch机制。显示Toast的时候会将其数值修改为0，
    showToast(waitingForToast);
    //这里会等待主线程显示Toast，也就是CountDownLatch变为0。然后就可以继续后面的操作
    if (!waitingForToast.wait(5, SECONDS)) {
      CanaryLog.d("Did not dump heap, too much time waiting for Toast.");
      return RETRY_LATER;
    }
    //创建一个Notification通知
    Notification.Builder builder = new Notification.Builder(context)
        .setContentTitle(context.getString(R.string.leak_canary_notification_dumping));
    Notification notification = LeakCanaryInternals.buildNotification(context, builder);
    NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
    int notificationId = (int) SystemClock.uptimeMillis();
    notificationManager.notify(notificationId, notification);

    Toast toast = waitingForToast.get();
    try {
      //创建heap堆的快照信息，可以获知程序的哪些部分正在使用大部分的内存
      Debug.dumpHprofData(heapDumpFile.getAbsolutePath());
      //关闭Toask和Notification通知
      cancelToast(toast);
      notificationManager.cancel(notificationId);
      return heapDumpFile;
    } catch (Exception e) {
      CanaryLog.d(e, "Could not dump heap");
      // Abort heap dump
      return RETRY_LATER;
    }
  }

这里会创建一个.hprof文件，然后显示一个Toast和Notification通知，再将内存泄漏时候的堆的快照信息保存的.hprof文件中，最后将Toast和Notification通知关闭。所以执行完这个操作之后，我们生成的.hprof文件中就保存了对应的内存泄漏时的堆的相关信息了。

快照文件分析

当生成了文件以后，会通过heapdumpListener来分析生成的快照文件。这里的listener默认的是ServiceHeapDumpListener类

  //AndroidRefWatcherBuilder.java
  @Override protected @NonNull HeapDump.Listener defaultHeapDumpListener() {
    return new ServiceHeapDumpListener(context, DisplayLeakService.class);
  }

我们看一下它的analyze方法

  //ServiceHeapDumpListener.java
   public void analyze(@NonNull HeapDump heapDump) {
    checkNotNull(heapDump, "heapDump");
    HeapAnalyzerService.runAnalysis(context, heapDump, listenerServiceClass);
  }
  //HeapAnalyzerService.java
  public static void runAnalysis(Context context, HeapDump heapDump,
      Class listenerServiceClass) {
    setEnabledBlocking(context, HeapAnalyzerService.class, true);
    setEnabledBlocking(context, listenerServiceClass, true);
    Intent intent = new Intent(context, HeapAnalyzerService.class);
    //这里的listenerServiceClass是DisplayLeakService
    intent.putExtra(LISTENER_CLASS_EXTRA, listenerServiceClass.getName());
    intent.putExtra(HEAPDUMP_EXTRA, heapDump);
    //启动一个前台的服务，启动时，会调用onHandleIntent方法，该方法在父类中实现了。实现中会调用onHandleIntentInForeground()方法
    ContextCompat.startForegroundService(context, intent);
  }

这里启动了一个服务来进行对于文件的分析功能。当启动服务的时候会调用onHandleIntent方法。HeapAnalyzerService的onHandleIntent是在其父类中实现的。

//ForegroundService.java
@Override protected void onHandleIntent(@Nullable Intent intent) {
  onHandleIntentInForeground(intent);
}

所以会调用onHandleIntentInForeground这个方法。

    protected void onHandleIntentInForeground(@Nullable Intent intent) {
        String listenerClassName = intent.getStringExtra(LISTENER_CLASS_EXTRA);
        HeapDump heapDump = (HeapDump) intent.getSerializableExtra(HEAPDUMP_EXTRA);
        //创建一个堆分析器
        HeapAnalyzer heapAnalyzer = new HeapAnalyzer(heapDump.excludedRefs, this, heapDump.reachabilityInspectorClasses);
        //**重点分析方法***分析内存泄漏结果
        AnalysisResult result = heapAnalyzer.checkForLeak(heapDump.heapDumpFile, heapDump.referenceKey, heapDump.computeRetainedHeapSize);
        //调用接口，将结果回调给listenerClassName所对应的类（这里是DisplayLeakService类）来进行处理
        AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);
    }

这里会创建一个堆分析器，对于我们的快照文件进行分析，然后将结果通过AbstractAnalysisResultService的方法，将结果交给DisplayLeakService类来进行处理。

检测泄漏结果

HeapAnalyzer类的作用主要就是通过对.hprof文件的分析，检测我们监控的对象是否发生了内存的泄漏

//HeapAnalyzer.java
//将hprof文件解析，解析为对应的AnalysisResult对象
public @NonNull AnalysisResult checkForLeak(@NonNull File heapDumpFile, @NonNull String referenceKey, boolean computeRetainedSize) {
    long analysisStartNanoTime = System.nanoTime();

    if (!heapDumpFile.exists()) {
        Exception exception = new IllegalArgumentException("File does not exist: " + heapDumpFile);
        return failure(exception, since(analysisStartNanoTime));
    }

    try {
        //开始读取Dump文件
        listener.onProgressUpdate(READING_HEAP_DUMP_FILE);
        HprofBuffer buffer = new MemoryMappedFileBuffer(heapDumpFile);
        //.hprof的解析器,这个是haha库的类
        HprofParser parser = new HprofParser(buffer);
        listener.onProgressUpdate(PARSING_HEAP_DUMP);
        //解析生成快照，快照中会包含所有被引用的对象信息
        Snapshot snapshot = parser.parse();
        listener.onProgressUpdate(DEDUPLICATING_GC_ROOTS);
        deduplicateGcRoots(snapshot);
        listener.onProgressUpdate(FINDING_LEAKING_REF);
        //根据key值，查找快照中是否有所需要的对象
        Instance leakingRef = findLeakingReference(referenceKey, snapshot);
        if (leakingRef == null) {
            //表示对象不存在，在gc的时候，进行了回收。表示没有内存泄漏
            String className = leakingRef.getClassObj().getClassName();
            return noLeak(className, since(analysisStartNanoTime));
        }
        //检测泄漏的路径，并将检测的结果进行返回
        return findLeakTrace(analysisStartNanoTime, snapshot, leakingRef, computeRetainedSize);
    } catch (Throwable e) {
        return failure(e, since(analysisStartNanoTime));
    }
}

这个方法使用了haha三方类库来对.hprof文件解析以及处理。里面的主要流程如下：

  1. 创建一个.hprof文件的buffer来进行文件的读取
  2. 通过HprofParser解析器来解析hprof文件，生成Snapshot对象。在这一步中构建了一颗对象的引用关系树，我们可以在这颗树中查询各个Object的信息，包括Class信息、内存地址、持有的引用以及被持有引用的关系。
  3. 根据传入的监控的对象key值，获取其在Snapshot中所对应的引用leakingRef。
  4. 分析leakingRef，获取到内存泄漏的路径。这里会找到一条到泄漏对象的最短引用路径。这个过程由findLeakTrace来完成，实际上寻找最短引用路径的逻辑是封装在PathsFromGCRootsComputerImpl类的getNextShortestPath和processCurrentReferrefs方法中
泄漏的通知

当找到我们的内存泄漏的路径后，会调用AbstractAnalysisResultService.sendResultToListener将结果交给DisplayLeakService类来进行处理。

//AbstractAnalysisResultService.java
public static void sendResultToListener(@NonNull Context context,
    @NonNull String listenerServiceClassName,
    @NonNull HeapDump heapDump,
    @NonNull AnalysisResult result) {
  Class listenerServiceClass;
  try {
    //通过反射获取到一个类信息
    listenerServiceClass = Class.forName(listenerServiceClassName);
  } catch (ClassNotFoundException e) {
    throw new RuntimeException(e);
  }
  Intent intent = new Intent(context, listenerServiceClass);
  //将结果保存到文件中，然后将文件路径传递给service
  File analyzedHeapFile = AnalyzedHeap.save(heapDump, result);
  if (analyzedHeapFile != null) {
    intent.putExtra(ANALYZED_HEAP_PATH_EXTRA, analyzedHeapFile.getAbsolutePath());
  }
  //启动服务，然后传递内存泄漏分析的结果文件所对应的位置
  ContextCompat.startForegroundService(context, intent);
}

这里会启动一个DisplayLeakService服务，传递了对应的内存泄漏分析结果的文件路径信息。

然后通过onHandleIntent()->onHandleIntentInForeground()->onHeapAnalyzed()。最终调用了DisplayLeakService的onHeapAnalyzed方法

protected final void onHeapAnalyzed(@NonNull AnalyzedHeap analyzedHeap) {
    HeapDump heapDump = analyzedHeap.heapDump;
    AnalysisResult result = analyzedHeap.result;
    //根据泄漏的信息，生成提示的String字符串
    String leakInfo = leakInfo(this, heapDump, result, true);
    CanaryLog.d("%s", leakInfo);
    //重命名.hprof文件
    heapDump = renameHeapdump(heapDump);
    //保存分析的结果
    boolean resultSaved = saveResult(heapDump, result);
    //结果表头
    String contentTitle;
    if (resultSaved) {
        PendingIntent pendingIntent = DisplayLeakActivity.createPendingIntent(this, heapDump.referenceKey);
        if (result.failure != null) {
            //分析失败
            contentTitle = getString(R.string.leak_canary_analysis_failed);
        } else {
            String className = classSimpleName(result.className);
            if (result.leakFound) {//检测到内存泄漏
                if (result.retainedHeapSize == AnalysisResult.RETAINED_HEAP_SKIPPED) {
                    if (result.excludedLeak) {//被排除的检测结果
                        contentTitle = getString(R.string.leak_canary_leak_excluded, className);
                    } else {
                        contentTitle = getString(R.string.leak_canary_class_has_leaked, className);
                    }
                } else {
                    String size = formatShortFileSize(this, result.retainedHeapSize);
                    if (result.excludedLeak) {
                        contentTitle = getString(R.string.leak_canary_leak_excluded_retaining, className, size);
                    } else {
                        contentTitle = getString(R.string.leak_canary_class_has_leaked_retaining, className, size);
                    }
                }
            } else {
                //未检测到内存泄漏
                contentTitle = getString(R.string.leak_canary_class_no_leak, className);
            }
        }
        String contentText = getString(R.string.leak_canary_notification_message);
        //***重点方法***显示一个Notification通知
        showNotification(pendingIntent, contentTitle, contentText);
    } else {
        onAnalysisResultFailure(getString(R.string.leak_canary_could_not_save_text));
    }
    //钩子函数，可以重写此方法，将内存的泄露信息和对应的.hprof文件上传到服务器。
    // 需要注意，leakfind和excludedLeak的情况都会调用这个方法
    afterDefaultHandling(heapDump, result, leakInfo);
}

这个服务的作用就是将我们分析之后的泄漏路径的相关信息通过Notification的通知形式，告知用户具体的内存泄漏情况。

在程序的最后有一个afterDefaultHandling方法，这个方法是一个空实现，用户可以覆写这个方法来实现将内存泄漏的信息上传到服务器的功能

到这里为止LeakCanary的整个实现流程解析完成了。

学习到的新知识

整篇的学习，还是学到了一些之前没有认识到的东西的。

  1. 主要是通过registerActivityLifecycleCallbacks来注册对于我们销毁的Activity的监听。
  2. 使用了弱引用的引用队列方式对于我们已经销毁的Activity的引用信息进行监控，检测其是否被回收。
  3. 对于执行垃圾回收需要使用Runtime.getRuntime().gc()。
  4. 可以使用CountDownLatch来实现线程之间的同步处理。比如说这套源码里面对于showToast的处理。
  5. 不同的Android版本本身可能就存在一些内存泄漏的情况。
  6. LeakCanary可以通过覆写afterDefaultHandling方法来实现对于内存泄漏信息的自行处理

源码解析项目地址：leakcanary-source

本文由 开了肯 发布！

同步公众号[开了肯]

你可能感兴趣的:(LeakCanary源码解析)

  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istioistio云原生服务发现
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
  • Java集合类框架源码分析 之 RoleList源码解析 【6】 yunzhonghefei Java集合类源码分析RoleList源码解析
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
  • VITS 源码解析2-模型概述 迪三 #NN_Audio音频人工智能
    VITs是文本到语音(Text-to-Speech,TTS)任务中最流行的技术之一，其实现思路是将文本语音信息融合到了HiFiGAN潜空间内,通过文本控制HiFiGAN的生成器，输出含文本语义的声音。VITs主要以GAN的方式训练,其生成器G是SynthesizerTrn，判别器D是MPD。VITS的判别器几乎和HiFiGAN一样，生成器则融合了文本、时序、声音三大类模型1.文件概述模型部分包含三
  • RBtree 努力的小带土 侯捷老师STLc++蓝桥杯
    终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！-【码炫课堂收费课节选之-红黑树源码解析及手写红黑树】_哔哩哔哩_bilibiliB站的听课记录，并写下如下红黑树c++版本代码，该课程真的史诗级推荐！/*RBtreeNode.h*****/#pragmaonceenum{RED=false,BLACK=true};templateclassRBtreeNode{public://红黑树的左右节点
  • 深入理解Kubernetes：kube-scheduler源码解析 mujingluo kubernetes容器云原生
    Kubernetes的调度器（kube-scheduler）是整个系统中至关重要的组件，它负责将待调度的Pods分配到合适的节点上。本文将深入分析kube-scheduler的源码，揭示其内部工作机制。kube-scheduler的核心功能kube-scheduler的核心功能包括：监听Pod变化：通过KubernetesAPI监听所有未调度的Pods。过滤（Filtering）：根据一系列规则（
  • 【Vesta发号器源码】PropertyMachineIdsProvider DeanChangDM
    Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
  • StarRocks分布式元数据源码解析 不甚了然 Iceberg知识集StarRocksIceberg数据湖湖仓一体大数据
    1.支持元数据表https://github.com/StarRocks/starrocks/pull/44276/files核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段public static LogicalIcebergMetadata
  • 【Starrocks】建表篇Fe源码解析 数算七弦 Starrocks大数据
    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
  • 智能农业设备软件工程师如何集成和管理农业物联网（IoT）平台 openwin_top 智能农业设备软件工程师物联网python开发语言深度学习大数据智能农业
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业物联网（IoT）平台涉及多个步骤，包括设备连接、数据收集、数据传输、数据存储、数据分析和展示。以下是详细分析和示例代码展示。1.设备连接和数据收集首先，智能农业设备需要能够与传感器和执
  • 智能农业设备软件工程师如何集成和管理农业设备的远程更新系统 openwin_top 智能农业设备软件工程师深度学习大数据物联网人工智能网络智能农业
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业设备的远程更新系统涉及多个技术层面，包括设备固件的安全更新、版本控制、网络通信，以及设备管理平台的开发。下面我们详细分析这些步骤，并提供一个基本的示例代码来展示如何实现这个系统。1.系
  • 智能农业设备软件工程师如何处理设备的远程诊断和修复 openwin_top 智能农业设备软件工程师网络智能农业物联网人工智能大数据深度学习
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位处理智能农业设备的远程诊断和修复涉及几个关键步骤，包括设备的数据采集、数据传输、远程诊断、远程控制和修复。以下是详细分析和示例代码：1.数据采集智能农业设备通常配备传感器和控制器，这些设备不断采集环
  • android10 按键音量调节源码解析 @OuYang android
    /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.javastaticIAudioServicegetAudioService(){IAudioServiceaudioService=IAudioService.Stub.asInterface(ServiceManager.checkS
  • android10 Settings源码解析 @OuYang android
    /packages/apps/Settings/AndroidManifest.xml.................................................................................activity-alias是Android里为了重复使用Activity而设计的。对于activity-alias标签，它有一个属性叫android:
  • MyBatis 源码解析：XMLScriptBuilder 工作机制 捕风捉你 MyBatis源码解读mybatisjava
    摘要MyBatis提供了强大的动态SQL功能，它通过解析XML配置文件中的动态SQL标签（如、、等），来实现灵活的SQL生成。而XMLScriptBuilder类则负责解析这些XML配置并生成最终的SQL语句。本文将详细解析XMLScriptBuilder的工作机制，并通过自定义实现来帮助您深入理解该类的功能。前言MyBatis中的动态SQL功能是通过解析XML配置文件实现的。XML文件中包含了动
  • c#视觉应用开发中如何使用Emgu CV在C#中进行图像处理？ openwin_top C#视觉应用开发问题系列c#图像处理开发语言
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位EmguCV是OpenCV的.NET包装器，可以让开发者在.NET语言（如C#）中使用OpenCV的功能进行图像处理。在进行图像处理时，EmguCV提供了丰富的API可以使用。以下是使用EmguCV
  • Elasticsearch——配置详解 smart哥 elasticsearch专题elasticsearch搜索引擎
    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
  • Eventbus3.0源码解析 超威蓝猫l
    根据官方demo首先你需要先在activity中注册EventBus.getDefault().register(this);register所以我们先从getDefault方法开始看起/**Conveniencesingletonforappsusingaprocess-wideEventBusinstance.*/publicstaticEventBusgetDefault(){EventBu
  • 前端宝典之三：React源码解析之Fiber架构 桃子叔叔 大厂进阶前端深度解析系列react.js架构javascript
    本文主要内容：1、ReactConcurrent2、React15架构3、React16架构4、Fiber架构5、任务调度循环和fiber构造循环区别一、ReactConcurrentReact在解决CPU卡顿是会用到ReactConcurrent的概念，它是React中的一个重要特性和模块，主要的特点和原理如下一、主要特点和优势1、时间切片（TimeSlicing）允许将长时间运行的任务分割成小
  • Java集合之HashSet源码解析 气宇轩昂固执狂 JAVA面试笔试通关指南java开发语言HashSetHashSet源码
    一、HashSet概述：1、HashSet底层实现实际上就是利用HashMap的键（Key）来存储对象，原HashMap的键key的位置存放对象，值value的位置存放空的Object对象作为虚拟值；2、增加和删除都是直接调用HashMap的方法来实现的，没有修改和具体的查询方法，获取值只能通过iterator方法来迭代，迭代方法也是建立在HashMap的键的迭代方法上的。相关HashSet的操作
  • Spring之AOP底层源码解析（上） 阿立聊代码 spring代理模式
    动态代理代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。比如，现在存在一个UserService类：public class UserService  { public void test() {  System.out.println("test..."); }}此时，我们new一个UserService对象，然后执行test()方法，结果是
  • Spring Boot自动配置源码解析 一休哥助手 springbootjava数据库
    一、自动配置概述1.1什么是自动配置SpringBoot的自动配置是一种能够根据类路径中的依赖、配置文件中的属性以及其他条件，自动配置Spring应用上下文的功能。它通过扫描项目中的类和配置文件，判断哪些组件需要自动装配，从而减少了手动编写配置代码的繁琐过程。1.2自动配置的优点减少配置工作量：自动配置能够帮助开发者快速启动一个Spring应用，而不必担心各种复杂的XML或Java配置。智能化配置
  • Spring扩展点系列-InstantiationAwareBeanPostProcessor 码至终章 Spring生命周期扩展接口springsqljava扩展接口mavenspringboot
    文章目录简介测试一1、配置文件Bean注册2、单元测试方法3、测试类4、输出结果结论测试二1、测试类2、输出结果结论源码解析postProcessPropertiesCommonAnnotationBeanPostProcessorAnnotationInjectedBeanPostProcessor总结简介spring容器中Bean的生命周期内所有可扩展的点的调用顺序扩展接口实现接口Applic
  • MyBatis 源码解析：DefaultSqlSessionFactory 的创建与管理 捕风捉你 MyBatis源码解读mybatis
    摘要在MyBatis中，SqlSessionFactory是执行数据库操作的核心对象，它负责创建和管理SqlSession的生命周期。你是否想了解SqlSessionFactory的创建和管理过程？本文将通过自定义实现一个简化版的DefaultSqlSessionFactory，带你深入探讨MyBatis中DefaultSqlSessionFactory的创建与管理机制，并帮助你更好地掌握SqlS
  • FFmpeg源码解析系列（一）目录和编译 头快撑不住了 FFmpeg源码解析ffmpeg音视频视频编解码实时音视频图像处理
    引言当我们欣赏一部电影、观看一段视频或者享受一首音乐时，很少有人会停下来思考这一切是如何呈现在我们眼前的。然而，在每一帧的画面、每一秒的声音背后，有着一个不可思议的技术世界这个充满音视频的世界的核心之一，就是FFmpeg。FFmpeg是一个强大而复杂的多媒体处理工具，它为视频和音频编解码、流媒体传输、格式转换等提供了优秀的解决方案。在这个系列博客中，我们将深入探讨FFmpeg源码，解析它的工作原理
  • Spark MLlib LinearRegression线性回归算法源码解析 SmileySure Spark人工智能算法SparkMLlib
    线性回归一元线性回归hθ(x)=θ0+θ1xhθ(x)=θ0+θ1x——————–1多元线性回归hθ(x)=∑mi=1θixi=θTXhθ(x)=∑i=1mθixi=θTX—————–2损失函数J(θ)=1/2∑mi=1(hθ(xi)−yi)2J(θ)=1/2∑i=1m(hθ(xi)−yi)2—————31/2是为了求导时系数为1，平方里是真实值减去估计值我们的目的就是求其最小值最小二乘法要求较为
  • HashMap源码解析 dlwlrma ⥳ 兴趣类哈希算法散列表算法
    目录一:put方法流程二：get方法三：扩容机制一：put方法流程publicVput(Kkey,Vvalue){returnputVal(hash(key),key,value,false,true);}finalVputVal(inthash,Kkey,Vvalue,booleanonlyIfAbsent,booleanevict){Node[]tab;Nodep;intn,i;//判断数组是
  • Spring之启动过程源码解析 阿立聊代码 springspring数据库oracle
    前言分析通常，我们说的Spring启动，就是构造ApplicationContext对象以及调用refresh()方法的过程。首先，Spring启动过程主要做了这么几件事情：构造一个BeanFactory对象解析配置类，得到BeanDefinition，并注册到BeanFactory中解析@ComponentScan，此时就会完成扫描解析@Import解析@Bean...因为Application
  • 【HuggingFace Transformers】BertIntermediate 和 BertPooler源码解析 CS_木成河 HuggingFace深度学习人工智能bertpython大模型Transformer
    BertIntermediate和BertPooler源码解析1.介绍1.1位置与功能1.2相似点与不同点2.源码解析2.1BertIntermediate源码解析2.2BertPooler源码解析1.介绍1.1位置与功能(1)BertIntermediate位置：位于BertLayer的注意力层（BertSelfAttention）和输出层（BertOutput）之间。功能：它执行一个线性变换（
  • vue.js项目实战案例详细源码讲解 程序员小羊！ Javavue.js前端javascript
    大家好，我是程序员小羊！前言：为帮助大家更好地掌握Vue.js项目的开发流程，我将为你讲解一个完整的Vue.js实战案例，并提供详细的源码解析。这个案例将涵盖从项目创建到实现各种功能模块的全过程，适合用于构建一个具有基本CRUD功能的简单任务管理应用。案例介绍我们将开发一个任务管理应用（TaskManager），它允许用户添加、查看、编辑和删除任务。这个应用将包括以下主要功能模块：任务列表显示：展
  • 书其实只有三类 西蜀石兰 类
    一个人一辈子其实只读三种书，知识类、技能类、修心类。 知识类的书可以让我们活得更明白。类似十万个为什么这种书籍，我一直不太乐意去读，因为单纯的知识是没法做事的，就像知道地球转速是多少一样（我肯定不知道），这种所谓的知识，除非用到，普通人掌握了完全是一种负担，维基百科能找到的东西，为什么去记忆？ 知识类的书，每个方面都涉及些，让自己显得不那么没文化，仅此而已。社会认为的学识渊博，肯定不是站在
  • 《TCP/IP 详解，卷1：协议》学习笔记、吐槽及其他 bylijinnan tcp
    《TCP/IP 详解，卷1：协议》是经典，但不适合初学者。它更像是一本字典，适合学过网络的人温习和查阅一些记不清的概念。 这本书，我看的版本是机械工业出版社、范建华等译的。这本书在我看来，翻译得一般，甚至有明显的错误。如果英文熟练，看原版更好： http://pcvr.nl/tcpip/ 下面是我的一些笔记，包括我看书时有疑问的地方，也有对该书的吐槽，有不对的地方请指正： 1.
  • Linux—— 静态IP跟动态IP设置 eksliang linuxIP
    一.在终端输入 vi /etc/sysconfig/network-scripts/ifcfg-eth0 静态ip模板如下： DEVICE="eth0" #网卡名称 BOOTPROTO="static" #静态IP（必须） HWADDR="00:0C:29:B5:65:CA" #网卡mac地址 IPV6INIT=&q
  • Informatica update strategy transformation 18289753290
    更新策略组件： 标记你的数据进入target里面做什么操作，一般会和lookup配合使用，有时候用0,1,1代表 forward  rejected rows被选中，rejected row是输出在错误文件里，不想看到reject输出，将错误输出到文件，因为有时候数据库原因导致某些column不能update，reject就会output到错误文件里面供查看，在workflow的
  • 使用Scrapy时出现虽然队列里有很多Request但是却不下载，造成假死状态 酷的飞上天空 request
    现象就是： 程序运行一段时间，可能是几十分钟或者几个小时，然后后台日志里面就不出现下载页面的信息，一直显示上一分钟抓取了0个网页的信息。 刚开始已经猜到是某些下载线程没有正常执行回调方法引起程序一直以为线程还未下载完成，但是水平有限研究源码未果。 经过不停的google终于发现一个有价值的信息，是给twisted提出的一个bugfix 连接地址如下http://twistedmatrix.
  • 利用预测分析技术来进行辅助医疗 蓝儿唯美 医疗
    2014年，克利夫兰诊所（Cleveland Clinic）想要更有效地控制其手术中心做膝关节置换手术的费用。整个系统每年大约进行2600例此类手术，所以，即使降低很少一部分成本，都可以为诊 所和病人节约大量的资金。为了找到适合的解决方案，供应商将视野投向了预测分析技术和工具，但其分析团队还必须花时间向医生解释基于数据的治疗方案意味着 什么。  克利夫兰诊所负责企业信息管理和分析的医疗
  • java 线程(一)：基础篇 DavidIsOK java多线程线程
                                                            &nbs
  • Tomcat服务器框架之Servlet开发分析 aijuans servlet
    最近使用Tomcat做web服务器，使用Servlet技术做开发时，对Tomcat的框架的简易分析： 疑问： 为什么我们在继承HttpServlet类之后，覆盖doGet(HttpServletRequest req, HttpServetResponse rep)方法后，该方法会自动被Tomcat服务器调用，doGet方法的参数有谁传递过来？怎样传递？ 分析之我见： doGet方法的
  • 揭秘玖富的粉丝营销之谜 与小米粉丝社区类似 aoyouzi 揭秘玖富的粉丝营销之谜
    玖富旗下悟空理财凭借着一个微信公众号上线当天成交量即破百万，第七天成交量单日破了1000万;第23天时，累计成交量超1个亿……至今成立不到10个月，粉丝已经超过500万，月交易额突破10亿，而玖富平台目前的总用户数也已经超过了1800万，位居P2P平台第一位。很多互联网金融创业者慕名前来学习效仿，但是却鲜有成功者，玖富的粉丝营销对外至今仍然是个谜。   　　近日，一直坚持微信粉丝营销
  • Java web的会话跟踪技术 百合不是茶 url会话Cookie会话Seession会话Java Web隐藏域会话
    会话跟踪主要是用在用户页面点击不同的页面时,需要用到的技术点   会话:多次请求与响应的过程     1,url地址传递参数,实现页面跟踪技术          格式:传一个参数的 url?名=值     传两个参数的 url?名=值 &名=值   关键代码
  • web.xml之Servlet配置 bijian1013 javaweb.xmlServlet配置
    定义： <servlet> <servlet-name>myservlet</servlet-name> <servlet-class>com.myapp.controller.MyFirstServlet</servlet-class> <init-param> <param-name>
  • 利用svnsync实现SVN同步备份 sunjing SVN同步E000022svnsync镜像
    1. 在备份SVN服务器上建立版本库    svnadmin create test 2. 创建pre-revprop-change文件     cd test/hooks/     cp pre-revprop-change.tmpl pre-revprop-change 3. 修改pre-revprop-
  • 【分布式数据一致性三】MongoDB读写一致性 bit1129 mongodb
    本系列文章结合MongoDB，探讨分布式数据库的数据一致性，这个系列文章包括： 数据一致性概述与CAP 最终一致性(Eventually Consistency) 网络分裂(Network Partition)问题 多数据中心(Multi Data Center) 多个写者(Multi Writer)最终一致性 一致性图表(Consistency Chart) 数据
  • Anychart图表组件-Flash图转IMG普通图的方法 白糖_ Flash
    问题背景：项目使用的是Anychart图表组件，渲染出来的图是Flash的，往往一个页面有时候会有多个flash图，而需求是让我们做一个打印预览和打印功能，让多个Flash图在一个页面上打印出来。   那么我们打印预览的思路是获取页面的body元素，然后在打印预览界面通过$("body").append(html)的形式显示预览效果，结果让人大跌眼镜：Flash是
  • Window 80端口被占用 WHY? bozch 端口占用window
    平时在启动一些可能使用80端口软件的时候，会提示80端口已经被其他软件占用，那一般又会有那些软件占用这些端口呢？    下面坐下总结：         1、web服务器是最经常见的占用80端口的，例如：tomcat , apache  , IIS , Php等等；         2
  • 编程之美-数组的最大值和最小值-分治法（两种形式） bylijinnan 编程之美
    import java.util.Arrays; public class MinMaxInArray { /** * 编程之美 数组的最大值和最小值 分治法 * 两种形式 */ public static void main(String[] args) { int[] t={11,23,34,4,6,7,8,1,2,23}; int[]
  • Perl正则表达式 chenbowen00 正则表达式perl
    首先我们应该知道 Perl 程序中，正则表达式有三种存在形式，他们分别是： 匹配：m/<regexp>;/ （还可以简写为 /<regexp>;/ ，略去 m） 替换：s/<pattern>;/<replacement>;/ 转化：tr/<pattern>;/<replacemnt>;
  • [宇宙与天文]行星议会是否具有本行星大气层以外的权力呢? comsci
          举个例子: 地球,地球上由200多个国家选举出一个代表地球联合体的议会,那么现在地球联合体遇到一个问题,地球这颗星球上面的矿产资源快要采掘完了....那么地球议会全体投票,一致通过一项带有法律性质的议案,既批准地球上的国家用各种技术手段在地球以外开采矿产资源和其它资源........    &
  • Oracle Profile 使用详解 daizj oracleprofile资源限制
    Oracle Profile 使用详解 转 一、目的： Oracle系统中的profile可以用来对用户所能使用的数据库资源进行限制，使用Create Profile命令创建一个Profile，用它来实现对数据库资源的限制使用，如果把该profile分配给用户，则该用户所能使用的数据库资源都在该profile的限制之内。 二、条件： 创建profile必须要有CREATE PROFIL
  • How HipChat Stores And Indexes Billions Of Messages Using ElasticSearch & Redis dengkane elasticsearchLucene
    This article is from an interview with Zuhaib Siddique, a production engineer at HipChat, makers of group chat and IM for teams. HipChat started in an unusual space, one you might not
  • 循环小示例，菲波拉契序列，循环解一元二次方程以及switch示例程序 dcj3sjt126com c算法
    # include <stdio.h> int main(void) { int n; int i; int f1, f2, f3; f1 = 1; f2 = 1; printf("请输入您需要求的想的序列："); scanf("%d", &n); for (i=3; i<n; i
  • macbook的lamp环境 dcj3sjt126com lamp
      sudo vim /etc/apache2/httpd.conf   /Library/WebServer/Documents 是默认的网站根目录   重启Mac上的Apache服务   这个命令很早以前就查过了，但是每次使用的时候还是要在网上查： 停止服务：sudo /usr/sbin/apachectl stop 开启服务：s
  • java ArrayList源码 下 shuizhaosi888 ArrayList源码
    版本 jdk-7u71-windows-x64   JavaSE7 ArrayList源码上：http://flyouwith.iteye.com/blog/2166890     /** * 从这个列表中移除所有c中包含元素 */ public boolean removeAll(Collection<?> c) {
  • Spring Security（08）——intercept-url配置 234390216 Spring Securityintercept-url访问权限访问协议请求方法
    intercept-url配置 目录 1.1     指定拦截的url 1.2     指定访问权限 1.3     指定访问协议 1.4     指定请求方法   1.1   &n
  • Linux环境下的oracle安装 jayung oracle
    linux系统下的oracle安装 本文档是Linux(redhat6.x、centos6.x、redhat7.x) 64位操作系统安装Oracle 11g(Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production)，本文基于各种网络资料精心整理而成，共享给有需要的朋友。如有问题可联系：QQ：52-7
  • hotspot虚拟机 leichenlei javaHotSpotjvm虚拟机文档
    JVM参数  http://docs.oracle.com/javase/6/docs/technotes/guides/vm/index.html   JVM工具 http://docs.oracle.com/javase/6/docs/technotes/tools/index.html   JVM垃圾回收 http://www.oracle.com
  • 读《Node.js项目实践：构建可扩展的Web应用》 ——引编程慢慢变成系统化的“砌砖活” noaighost Webnode.js
    读《Node.js项目实践：构建可扩展的Web应用》 ——引编程慢慢变成系统化的“砌砖活” 眼里的Node.JS 初初接触node是一年前的事，那时候年少不更事。还在纠结什么语言可以编写出牛逼的程序，想必每个码农都会经历这个月经性的问题：微信用什么语言写的？facebook为什么推荐系统这么智能，用什么语言写的？dota2的外挂这么牛逼，用什么语言写的？……用什么语言写这句话，困扰人也是阻碍
  • 快速开发Android应用 rensanning android
    Android应用开发过程中，经常会遇到很多常见的类似问题，解决这些问题需要花时间，其实很多问题已经有了成熟的解决方案，比如很多第三方的开源lib，参考 Android Libraries 和 Android UI/UX Libraries。 编码越少，Bug越少，效率自然会高。 但可能由于 根本没听说过、听说过但没用过、特殊原因不能用、自己已经有了解决方案等等原因，这些成熟的解决
  • 理解Java中的弱引用 tomcat_oracle java工作面试
    　不久之前，我 面试了一些求职Java高级开发工程师的应聘者。我常常会面试他们说，“你能给我介绍一些Java中得弱引用吗？”，如果面试者这样说，“嗯，是不是垃圾回收有关的？”，我就会基本满意了，我并不期待回答是一篇诘究本末的论文描述。 　　然而事与愿违，我很吃惊的发现，在将近20多个有着平均5年开发经验和高学历背景的应聘者中，居然只有两个人知道弱引用的存在，但是在这两个人之中只有一个人真正了
  • 标签输出html标签" target="_blank">关于标签输出html标签 xshdch jsp
    http://back-888888.iteye.com/blog/1181202 关于<c:out value=""/>标签的使用，其中有一个属性是escapeXml默认是true(将html标签当做转移字符，直接显示不在浏览器上面进行解析)，当设置escapeXml属性值为false的时候就是不过滤xml，这样就能在浏览器上解析html标签， &nb
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他