01_小小鱼_01
01_小小鱼_01

LeakCanary 源码解析

一、 前言

1. Java 内存模型
image.png
运行时数据区域
名称 特征 作用 配置参数 异常
程序计数器 占用内存小，线程私有，生命周期与线程相同 大致为字节码行号指示器 无 无
虚拟机栈 线程私有，生命周期与线程相同，使用连续的内存空间 Java 方法执行的内存模型，存储局部变量表、操作栈、动态链接、方法出口等信息 -Xss StackOverflowError、OutOfMemoryError
java堆 线程共享，生命周期与虚拟机相同，可以不使用连续的内存地址 保存对象实例，所有对象实例（包括数组）都要在堆上分配 -Xms、-Xsx、-Xmn OutOfMemoryError
方法区 线程共享，生命周期与虚拟机相同，可以不使用连续的内存地址 存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据 -XX:PermSize:16M 、-XX:MaxPermSize64M OutOfMemoryError
运行时常量池 方法区的一部分，具有动态性 存放字面量及符号引用
2. Java垃圾回收策略
  • 引用计数算法：给对象中添加一个引用计数器，每当有引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为0的对象就是不可能再被使用。
  • 可达性分析算法：通过一系列的称为"GC Root"的对象作为起点，从这些节点开始向下搜索，搜素所走过的路径称为引用链（Reference Chain），当一个对象到GC Root没有任何的引用链相连，就判定对象可以被回收
对象可达性
3. Java 四种引用类型
  • 强引用：默认的引用方式，当内存空间不足，JVM宁愿触发OOM，也不会对这部分内存进行回收。
Object obj = new Object();
obj = null;
  • 软引用(SoftReference)：当内存空间不足的时候，JVM会回收这部分内存，一般用来做缓存策略。
  • 弱引用(WeakReference): 当GC回收的时候，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收这部分内存。
  • 虚引用(PhantomReference):当 GC回收的时候会回收这部分内存， 主要用于检测对象是否已经从内存中删除。
代码示例
public class TestReference {

    public static void main(String[] args) throws InterruptedException {
        ReferenceQueue referenceQueue = new ReferenceQueue<>();
        String sw = "虚引用";

        switch (sw) {
            case "软引用":
                Object objSoft = new Object();
                SoftReference softReference = new SoftReference<>(objSoft, referenceQueue);
                System.out.println("GC前获取:" + softReference.get());
                objSoft = null;
                System.gc();
                Thread.sleep(1000);
                System.out.println("GC后获取:" + softReference.get());
                System.out.println("队列中的结果:" + referenceQueue.poll());
                break;
            case "弱引用":
                Object objWeak = new Object();
                WeakReference weakReference = new WeakReference<>(objWeak, referenceQueue);
                System.out.println("GC前获取:" + weakReference.get());
                objWeak = null;
                System.gc();
                Thread.sleep(1000);
                System.out.println("GC后获取:" + weakReference.get());
                System.out.println("队列中的结果:" + referenceQueue.poll());
                break;
            case "虚引用":
                Object objPhan = new Object();
                PhantomReference phantomReference = new PhantomReference<>(objPhan, referenceQueue);
                System.out.println("GC前获取:" + phantomReference.get());
                objPhan = null;
                System.gc();
                //此处的区别是当objPhan的内存被gc回收之前虚引用就会被加入到ReferenceQueue队列中，其他的引用都为当引用被gc掉时候，引用会加入到ReferenceQueue中
                Thread.sleep(1000);
                System.out.println("GC后获取:" + phantomReference.get());
                System.out.println("队列中的结果:" + referenceQueue.poll());
                break;
        }
    }
}
 
 
软引用运行结果：
 
 
 
 
  
 
   
  
   
 
  
 
  

    软引用运行结果 
  
 
 
 
 
 
 
弱引用运行结果:
 
 
 
 
  
 
   
  
   
 
  
 
  

    弱引用运行结果 
  
 
 
 
 
 
 
虚引用运行结果:
 
 
 
 
  
 
   
  
   
 
  
 
  

    虚引用运行结果 
  
 
 
 
 
 
 
二、 集成
 
 
build.gradle文件
 
 
dependencies {
   // debug 版本依赖
  debugImplementation 'com.squareup.leakcanary:leakcanary-android:1.6.2'
  // release 版本依赖  
  releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.2'
  // 如果使用了 support fragment，请同时依赖
  debugImplementation 'com.squareup.leakcanary:leakcanary-support-fragment:1.6.2'

  // 最新2.0版本，只需要导入如下依赖，不再需要在Application里面添加其他代码
  // debugImplementation because LeakCanary should only run in debug builds.
  // debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.0-alpha-2'
}

 
 
Application#onCreate方法
 
 
if (LeakCanary.isInAnalyzerProcess(this)) {
  // This process is dedicated to LeakCanary for heap analysis.
  // You should not init your app in this process.
  return;
}
LeakCanary.install(this);

 
 
三、 LeakCanary源码导读
 
 
3.1. LeakCanary项目架构
 
 
LeakCanary 项目结构图：
 
 
 
 
  
 
   
  
   
 
  
 
  

    LeakCanary项目结构 
  
 
 
 
 
 
 
     
  
  • leakcanary-analyzer : 负责分析内存泄漏
    •  
  
  • leakcanary-android : android 核心模块以及通知、界面展示等
    •  
  
  • leakcanary-android-instrumentation : 单元测试使用
    •  
  
  • leakcanary-sample : 使用案例
    •  
  
  • leakcanary-support-fragment : 支持 fragment v4包
    •  
  
  • leakcanary-watcher : 负责监听内存泄漏
    •  
  
  • leakcanary-android-no-op : release 版本使用
    •  
 
 
 
3.2. LeakCanary执行过程
 
 
 
  
 
   
  
   
 
  
 
  

    LeakCanary执行过程 
  
 
 
 
 
3.3. LeakCanary初始化
 
 
  /**
   * Whether the current process is the process running the {@link HeapAnalyzerService}, which is
   * a different process than the normal app process.
   */
  public static boolean isInAnalyzerProcess(@NonNull Context context) {
    Boolean isInAnalyzerProcess = LeakCanaryInternals.isInAnalyzerProcess;
    // This only needs to be computed once per process.
    Log.d("LeakCanary", "isInAnalyzerProcess = " + isInAnalyzerProcess);
    if (isInAnalyzerProcess == null) {
      // HeapAnalyzerService进程名是否等于主进程名称
      isInAnalyzerProcess = isInServiceProcess(context, HeapAnalyzerService.class);
      LeakCanaryInternals.isInAnalyzerProcess = isInAnalyzerProcess;
    }
    return isInAnalyzerProcess;
  }

  public static @NonNull void install(@NonNull Application application) {
    refWatcher(application)
        .listenerServiceClass(DisplayLeakService.class)  // 设置 heapDumpListener
        .excludedRefs(AndroidExcludedRefs.createAppDefaults().build()) // 去除Android SDK 引起的内存泄漏
        .buildAndInstall();  //创建RefWatcher
  }

  public static @NonNull AndroidRefWatcherBuilder refWatcher(@NonNull Context context) {
    return new AndroidRefWatcherBuilder(context);
  }

 
 
isInAnalyzerProcess方法，用于检测内存分析进程是否和主进程名相同，如果是相同的，则设置RefWatcher = DISABLED ，不做任何处理。release 版本是通过以下以来确定的。
 // release 版本依赖
 releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.2'
 
 
3.4 AndroidRefWatcherBuilder 对象
 
 
  public @NonNull AndroidRefWatcherBuilder listenerServiceClass(
      @NonNull Class listenerServiceClass) {
    // isAssignableFrom()方法是判断是否为某个类的父类，instanceof()方法是判断是否某个类的子类。
    //（https://www.cnblogs.com/bethunebtj/p/4681438.html）
    enableDisplayLeakActivity = DisplayLeakService.class.isAssignableFrom(listenerServiceClass);
    return heapDumpListener(new ServiceHeapDumpListener(context, listenerServiceClass));
  }

  public final T heapDumpListener(HeapDump.Listener heapDumpListener) {
      this.heapDumpListener = heapDumpListener;
      return self();
  }

  public final T excludedRefs(ExcludedRefs excludedRefs) {
    heapDumpBuilder.excludedRefs(excludedRefs);
    return self();
  }

  @Override protected @NonNull HeapDumper defaultHeapDumper() {
    LeakDirectoryProvider leakDirectoryProvider =
        LeakCanaryInternals.getLeakDirectoryProvider(context);
    return new AndroidHeapDumper(context, leakDirectoryProvider);
  }

  public @NonNull RefWatcher buildAndInstall() {
    if (LeakCanaryInternals.installedRefWatcher != null) {
      throw new UnsupportedOperationException("buildAndInstall() should only be called once.");
    }
    RefWatcher refWatcher = build();
    if (refWatcher != DISABLED) {
      Log.d("LeakCanary", "enableDisplayLeakActivity = " + enableDisplayLeakActivity);
      if (enableDisplayLeakActivity) {
        LeakCanaryInternals.setEnabledAsync(context, DisplayLeakActivity.class, true);
      }
      Log.d("LeakCanary", "watchActivities = " + watchActivities);
      if (watchActivities) {
        ActivityRefWatcher.install(context, refWatcher);
      }
      Log.d("LeakCanary", "watchFragments = " + watchFragments);
      if (watchFragments) {
        FragmentRefWatcher.Helper.install(context, refWatcher);
      }
    }
    LeakCanaryInternals.installedRefWatcher = refWatcher;
    return refWatcher;
  }

  public final RefWatcher build() {
      if (isDisabled()) {
          return RefWatcher.DISABLED; 
      }
      if (heapDumpBuilder.excludedRefs == null) {
          heapDumpBuilder.excludedRefs(defaultExcludedRefs());
      }
      HeapDump.Listener heapDumpListener = this.heapDumpListener;
      if (heapDumpListener == null) {
          heapDumpListener = defaultHeapDumpListener();
      }
      DebuggerControl debuggerControl = this.debuggerControl;
      if (debuggerControl == null) {
          // 走这里
          debuggerControl = defaultDebuggerControl();
      }
      HeapDumper heapDumper = this.heapDumper;
      if (heapDumper == null) {
          // 走这里
          heapDumper = defaultHeapDumper();
      }
      WatchExecutor watchExecutor = this.watchExecutor;
      if (watchExecutor == null) {
          // 走这里
          watchExecutor = defaultWatchExecutor();
      }
      GcTrigger gcTrigger = this.gcTrigger;
      if (gcTrigger == null) {
          // 走这里
          gcTrigger = defaultGcTrigger();
      }
      if (heapDumpBuilder.reachabilityInspectorClasses == null) {
          heapDumpBuilder.reachabilityInspectorClasses(defaultReachabilityInspectorClasses());
      }
      return new RefWatcher(watchExecutor, debuggerControl, gcTrigger
                            , heapDumper, heapDumpListener, heapDumpBuilder);
  }

  @Override protected @NonNull WatchExecutor defaultWatchExecutor() {
    return new AndroidWatchExecutor(DEFAULT_WATCH_DELAY_MILLIS);
  }

 
 
buildAndInstall方法则用于设置heapDumpListener用于分析hprof文件， 过滤掉因为Android SDK引起的系统内存泄漏引用， 展示DisplayLeakActivity桌面icon，监听Activity 以及Fragment生命周期，在其销毁的时候调用RefWatcher的watch方法分析是否会发生内存泄漏对象。build方法则是初始化RefWatcher对象，
 
 
关于设置DisplayLeakActivity enabled = true的地方，需要看看详细的代码
 
 
    LeakCanaryInternals.setEnabledAsync(context, DisplayLeakActivity.class, true);

    public static void setEnabledAsync(Context context, final Class componentClass,
                                       final boolean enabled) {
        final Context appContext = context.getApplicationContext();
        AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() {
            @Override
            public void run() {
                setEnabledBlocking(appContext, componentClass, enabled);
            }
        });
    }

    public static void setEnabledBlocking(Context appContext, Class componentClass,
                                          boolean enabled) {
        ComponentName component = new ComponentName(appContext, componentClass);
        PackageManager packageManager = appContext.getPackageManager();
        int newState = enabled ? COMPONENT_ENABLED_STATE_ENABLED : COMPONENT_ENABLED_STATE_DISABLED;
        // Blocks on IPC.
        packageManager.setComponentEnabledSetting(component, newState, DONT_KILL_APP);
    }

 
 
其实就是利用AsyncTask的THREAD_POOL_EXECUTOR线程池去执行PackageManager的setComponentEnabledSetting方法，动态设置COMPONENT_ENABLED_STATE_ENABLED
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
3.5 RefWatcher 对象
 
 
  private final Set retainedKeys;
  private final ReferenceQueue queue; // 引用队列

  public void watch(Object watchedReference) {
    watch(watchedReference, "");
  }

  public void watch(Object watchedReference, String referenceName) {
    if (this == DISABLED) {
      return;
    }
    checkNotNull(watchedReference, "watchedReference");
    checkNotNull(referenceName, "referenceName");
    final long watchStartNanoTime = System.nanoTime();
    String key = UUID.randomUUID().toString();
    retainedKeys.add(key);
    final KeyedWeakReference reference =
        new KeyedWeakReference(watchedReference, key, referenceName, queue);

    ensureGoneAsync(watchStartNanoTime, reference);
  }

  private void ensureGoneAsync(final long watchStartNanoTime,
                               final KeyedWeakReference reference) {
    // 检测线程调度器
    watchExecutor.execute(new Retryable() {
      @Override public Retryable.Result run() {
        return ensureGone(reference, watchStartNanoTime);
      }
    });
  }

  Retryable.Result ensureGone(final KeyedWeakReference reference, final long watchStartNanoTime) {
    long gcStartNanoTime = System.nanoTime();
    long watchDurationMs = NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);

    // 移除所有弱引用可达对象
    removeWeaklyReachableReferences();

    // 如果VM正连接到Debuger，忽略这次检测，因为Debugger可能会持有一些在当前上下文中不可见的对象，导致误判
    if (debuggerControl.isDebuggerAttached()) {
      // The debugger can create false leaks.
      return RETRY;
    }
    //上面执行 removeWeaklyReachableReferences 方法，判断是不是监视对象已经被回收了，如果被回收了，那么说明没有发生内存泄漏，直接结束
    if (gone(reference)) {
      return DONE;
    }
     // 手动触发一次 GC 垃圾回收
    gcTrigger.runGc();
    // 再次移除所有弱引用可达对象
    removeWeaklyReachableReferences();
    if (!gone(reference)) {
      long startDumpHeap = System.nanoTime();
      long gcDurationMs = NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);
      // 利用Debug生成Hprof文件
      File heapDumpFile = heapDumper.dumpHeap();
      if (heapDumpFile == RETRY_LATER) {
        // Could not dump the heap.
        return RETRY;
      }
      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.analyze(heapDump);  // 开始分析hprof文件
    }
    return DONE;
  }

  private boolean gone(KeyedWeakReference reference) {
    return !retainedKeys.contains(reference.key);
  }

  private void removeWeaklyReachableReferences() {
    // WeakReferences are enqueued as soon as the object to which they point to becomes weakly
    // reachable. This is before finalization or garbage collection has actually happened.
    KeyedWeakReference ref;
    while ((ref = (KeyedWeakReference) queue.poll()) != null) {
      retainedKeys.remove(ref.key);
    }
  }
 
 
RefWatcher很重要的方法就是watch方法， 其中参数watchedReference就是对应的view、activity、fragment对象。 通过UUID 函数生成唯一的标识添加到Set集合当中。 KeyedWeakReference继承了WeakReference，关联了watchedReference。当进弱引用对象发生回收的时候，虚拟机就会向该引用添加到与之关联的引用队列当中。
 
 
检测内存是否泄漏的过程也很简单：首先会清除所有的弱引用可达对象， 判断watchedReference对象是否已经被回收了， 如果没有，则手动进行一个GC，二次确认watchedReference对象是否被回收，如果没被回收则dump hprof文件，通知heapdumpListener分析hprof文件
 
 
3.6. AndroidWatchExecutor 类
 
 
public final class AndroidWatchExecutor implements WatchExecutor {

 static final String LEAK_CANARY_THREAD_NAME = "LeakCanary-Heap-Dump";
 private final Handler mainHandler;
 private final Handler backgroundHandler;
 private final long initialDelayMillis;
 private final long maxBackoffFactor;

 public AndroidWatchExecutor(long initialDelayMillis) {
   mainHandler = new Handler(Looper.getMainLooper());
   HandlerThread handlerThread = new HandlerThread(LEAK_CANARY_THREAD_NAME);
   handlerThread.start();
   backgroundHandler = new Handler(handlerThread.getLooper());
   this.initialDelayMillis = initialDelayMillis;
   maxBackoffFactor = Long.MAX_VALUE / initialDelayMillis;
 }

 @Override public void execute(@NonNull Retryable retryable) {
   if (Looper.getMainLooper().getThread() == Thread.currentThread()) {
     waitForIdle(retryable, 0);
   } else {
     postWaitForIdle(retryable, 0);
   }
 }

 private void postWaitForIdle(final Retryable retryable, final int failedAttempts) {
   mainHandler.post(new Runnable() {
     @Override public void run() {
       waitForIdle(retryable, failedAttempts);
     }
   });
 }

 private void waitForIdle(final Retryable retryable, final int failedAttempts) {
   // This needs to be called from the main thread.
   Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
     @Override public boolean queueIdle() {
       postToBackgroundWithDelay(retryable, failedAttempts);
       return false;
     }
   });
 }

 private void postToBackgroundWithDelay(final Retryable retryable, final int failedAttempts) {
   long exponentialBackoffFactor = (long) Math.min(Math.pow(2, failedAttempts), maxBackoffFactor);
   long delayMillis = initialDelayMillis * exponentialBackoffFactor;
   // 利用HandlerThread对象里面的Looper进行子线程任务
   backgroundHandler.postDelayed(new Runnable() {
     @Override public void run() {
       Retryable.Result result = retryable.run();
       if (result == RETRY) {
         postWaitForIdle(retryable, failedAttempts + 1);
       }
     }
   }, delayMillis);
 }
}

 
 
WatchExecutor 是一个线程调度器。包含了一个主线程 mainHandler 和后台线程backgroundHandler。整个的逻辑就是当主线程空闲的时候，才回去启动后台线程去执行Retryable.run方法。
 
 
3.7. AndroidHeapDumper 生成hprof文件
 
 
  public File dumpHeap() {
    // 生成hprof文件
    File heapDumpFile = leakDirectoryProvider.newHeapDumpFile();

    if (heapDumpFile == RETRY_LATER) {
      return RETRY_LATER;
    }

    FutureResult waitingForToast = new FutureResult<>();
    showToast(waitingForToast);

    if (!waitingForToast.wait(5, SECONDS)) {
      Log.d("LeakCanary", "Did not dump heap, too much time waiting for Toast.");
      CanaryLog.d("Did not dump heap, too much time waiting for Toast.");
      return RETRY_LATER;
    }
    // 创建正在dumping通知
    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 {
      // 系统Debug类提供的方法
      Debug.dumpHprofData(heapDumpFile.getAbsolutePath());
      cancelToast(toast);
      notificationManager.cancel(notificationId);
      return heapDumpFile;
    } catch (Exception e) {
      CanaryLog.d(e, "Could not dump heap");
      // Abort heap dump
      return RETRY_LATER;
    }
  }

  private void showToast(final FutureResult waitingForToast) {
    mainHandler.post(new Runnable() {
      @Override public void run() {
        if (resumedActivity == null) {
          waitingForToast.set(null);
          return;
        }
        final Toast toast = new Toast(resumedActivity);
        toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
        toast.setDuration(Toast.LENGTH_LONG);
        LayoutInflater inflater = LayoutInflater.from(resumedActivity);
        toast.setView(inflater.inflate(R.layout.leak_canary_heap_dump_toast, null));
        toast.show();
        // Waiting for Idle to make sure Toast gets rendered.
        Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
          @Override public boolean queueIdle() {
            waitingForToast.set(toast);
            Log.d("LeakCanary", "latch.countDown()");
            return false;
          }
        });
      }
    });
  }

 
 
dumpHeap方法利用Debug.dumpHprofData(String filePath)生成hprof文件，同时会展示Toast以及通知栏状态。如果dump失败或者Toast展示时间太长就会返回RETRY_LATER。
 
 
3.8 HeapAnalyzerService 分析hprof文件，找出泄漏路径
 
 
  @Override protected void onHandleIntentInForeground(@Nullable Intent intent) {
    if (intent == null) {
      CanaryLog.d("HeapAnalyzerService received a null intent, ignoring.");
      return;
    }
    String listenerClassName = intent.getStringExtra(LISTENER_CLASS_EXTRA);
    HeapDump heapDump = (HeapDump) intent.getSerializableExtra(HEAPDUMP_EXTRA);

    HeapAnalyzer heapAnalyzer =
        new HeapAnalyzer(heapDump.excludedRefs, this, heapDump.reachabilityInspectorClasses);

    Log.d("LeakCanary", "leak path:" + heapDump.heapDumpFile.getAbsolutePath());

    AnalysisResult result = heapAnalyzer.checkForLeak(heapDump.heapDumpFile, heapDump.referenceKey,
        heapDump.computeRetainedHeapSize);
    AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);
  }

 
 
HeapAnalyzer 是hprof文件解析类， 使用了squareup的另外一个开源库—Haha。
 
 
  public @NonNull AnalysisResult checkForLeak(@NonNull File heapDumpFile,
      @NonNull String referenceKey,
      boolean computeRetainedSize) {
    long analysisStartNanoTime = System.nanoTime();

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

    // Hprof 文件协议介绍： https://my.oschina.net/u/217380/blog/1507542
    try {
      listener.onProgressUpdate(READING_HEAP_DUMP_FILE);
      // 把hprof文件映射到内存 ByteBuffer[]
      HprofBuffer buffer = new MemoryMappedFileBuffer(heapDumpFile);
      HprofParser parser = new HprofParser(buffer);
      listener.onProgressUpdate(PARSING_HEAP_DUMP);
      // 创建了HprofParser对象，parse方法解析hprof协议，生成Snapshot
      Snapshot snapshot = parser.parse();
      listener.onProgressUpdate(DEDUPLICATING_GC_ROOTS);
      // 去除重复的GC root对象
      deduplicateGcRoots(snapshot);
      listener.onProgressUpdate(FINDING_LEAKING_REF);
      Instance leakingRef = findLeakingReference(referenceKey, snapshot);

      // 此对象不存在，表示已经被gc清除了，不存在泄露因此返回无泄漏
      // False alarm, weak reference was cleared in between key check and heap dump.
      if (leakingRef == null) {
        String className = leakingRef.getClassObj().getClassName();
        return noLeak(className, since(analysisStartNanoTime));
      }
      // 此对象存在, 也不能确认它内存泄漏了，要检测此对象的gc root
      return findLeakTrace(analysisStartNanoTime, snapshot, leakingRef, computeRetainedSize);
    } catch (Throwable e) {
      return failure(e, since(analysisStartNanoTime));
    }
  }

 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
3.9 DisplayLeakService 生成内存泄漏通知栏
 
 
  protected final void onHeapAnalyzed(@NonNull AnalyzedHeap analyzedHeap) {
    Log.d("LeakCanary", "[DisplayLeakService]: onHeapAnalyzed");
    HeapDump heapDump = analyzedHeap.heapDump;
    AnalysisResult result = analyzedHeap.result;

    String leakInfo = leakInfo(this, heapDump, result, true);
    CanaryLog.d("%s", leakInfo);

    heapDump = renameHeapdump(heapDump);
    boolean resultSaved = saveResult(heapDump, result);

    String contentTitle;
    if (resultSaved) {
      PendingIntent pendingIntent =
          DisplayLeakActivity.createPendingIntent(this, heapDump.referenceKey);
      if (result.failure != null) {
        contentTitle = "Leak 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);
      showNotification(pendingIntent, contentTitle, contentText);
    } else {
      onAnalysisResultFailure(getString(R.string.leak_canary_could_not_save_text));
    }

    afterDefaultHandling(heapDump, result, leakInfo);
  }

 
 
四、LeakCanary不足
 
 
虽然 LeakCanary 有诸多优点，但是它也有做不到的地方，比如说检测申请大容量内存导致的OOM问题、Bitmap内存未释放问题，Service 中的内存泄漏可能无法检测等。
 
 
五、延申阅读
 
 
1. Matrix ResourceCanary -- Activity 泄漏及Bitmap冗余检测
 2. Hprof 文件协议
 3. GC那些事儿--Android内存优化第一弹
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(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），它允许用户添加、查看、编辑和删除任务。这个应用将包括以下主要功能模块：任务列表显示：展
    
                    
    • 
                                
  • 戴尔笔记本win8系统改装win7系统
                                    sophia天雪
win7戴尔改装系统win8
                                    
    戴尔win8 系统改装win7 系统详述  
 
第一步：使用U盘制作虚拟光驱： 
        1）下载安装UltraISO：注册码可以在网上搜索。 
        2）启动UltraISO，点击“文件”—》“打开”按钮，打开已经准备好的ISO镜像文 

    
                                
    • 
                                
  • BeanUtils.copyProperties使用笔记
                                    bylijinnan
java
                                    
    BeanUtils.copyProperties VS PropertyUtils.copyProperties 
 
两者最大的区别是： 
BeanUtils.copyProperties会进行类型转换，而PropertyUtils.copyProperties不会。 
既然进行了类型转换，那BeanUtils.copyProperties的速度比不上PropertyUtils.copyProp
    
                                
    • 
                                
  • MyEclipse中文乱码问题
                                    0624chenhong
MyEclipse
                                    
    一、设置新建常见文件的默认编码格式，也就是文件保存的格式。 
在不对MyEclipse进行设置的时候，默认保存文件的编码，一般跟简体中文操作系统（如windows2000，windowsXP）的编码一致，即GBK。 
在简体中文系统下，ANSI 编码代表 GBK编码;在日文操作系统下，ANSI 编码代表 JIS 编码。 
Window-->Preferences-->General -
    
                                
    • 
                                
  • 发送邮件
                                    不懂事的小屁孩
send email
                                    
      
import org.apache.commons.mail.EmailAttachment;  
import org.apache.commons.mail.EmailException;  
import org.apache.commons.mail.HtmlEmail;  
import org.apache.commons.mail.MultiPartEmail;  

    
                                
    • 
                                
  • 动画合集
                                    换个号韩国红果果
htmlcss
                                    
    动画 指一种样式变为另一种样式 keyframes应当始终定义0 100 过程 
1 transition  制作鼠标滑过图片时的放大效果 
 

css
.wrap{
		width: 340px;height: 340px;
		position: absolute;
		top: 30%;
		left: 20%;
		overflow: hidden;
		bor
    
                                
    • 
                                
  • 网络最常见的攻击方式竟然是SQL注入
                                    蓝儿唯美
sql注入
                                    
    NTT研究表明，尽管SQL注入（SQLi）型攻击记录详尽且为人熟知，但目前网络应用程序仍然是SQLi攻击的重灾区。 
信息安全和风险管理公司NTTCom Security发布的《2015全球智能威胁风险报告》表明，目前黑客攻击网络应用程序方式中最流行的，要数SQLi攻击。报告对去年发生的60亿攻击 行为进行分析，指出SQLi攻击是最常见的网络应用程序攻击方式。全球网络应用程序攻击中，SQLi攻击占
    
                                
    • 
                                
  • java笔记2
                                    a-john
java
                                    
    类的封装： 
1，java中，对象就是一个封装体。封装是把对象的属性和服务结合成一个独立的的单位。并尽可能隐藏对象的内部细节（尤其是私有数据） 
2，目的：使对象以外的部分不能随意存取对象的内部数据（如属性），从而使软件错误能够局部化，减少差错和排错的难度。 
3，简单来说，“隐藏属性、方法或实现细节的过程”称为——封装。 
4，封装的特性： 
      4.1设置
    
                                
    • 
                                
  • [Andengine]Error：can't creat bitmap form path “gfx/xxx.xxx”
                                    aijuans
学习Android遇到的错误
                                    
            最开始遇到这个错误是很早以前了，以前也没注意，只当是一个不理解的bug，因为所有的texture，textureregion都没有问题，但是就是提示错误。 
 
昨天和美工要图片，本来是要背景透明的png格式，可是她却给了我一个jpg的。说明了之后她说没法改，因为没有png这个保存选项。 
 
我就看了一下，和她要了psd的文件，还好我有一点
    
                                
    • 
                                
  • 自己写的一个繁体到简体的转换程序
                                    asialee
java转换繁体filter简体
                                    
              今天调研一个任务，基于java的filter实现繁体到简体的转换，于是写了一个demo，给各位博友奉上，欢迎批评指正。 
         实现的思路是重载request的调取参数的几个方法，然后做下转换。 
          
    
                                
    • 
                                
  • android意图和意图监听器技术
                                    百合不是茶
android显示意图隐式意图意图监听器
                                    
    Intent是在activity之间传递数据;Intent的传递分为显示传递和隐式传递 
  
显式意图：调用Intent.setComponent() 或 Intent.setClassName() 或 Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。 
  
隐式意图;不指明调用的名称,根据设
    
                                
    • 
                                
  • spring3中新增的@value注解
                                    bijian1013
javaspring@Value
                                    
            在spring 3.0中，可以通过使用@value，对一些如xxx.properties文件中的文件，进行键值对的注入，例子如下： 
1.首先在applicationContext.xml中加入：    
<beans xmlns="http://www.springframework.
    
                                
    • 
                                
  • Jboss启用CXF日志
                                    sunjing
logjbossCXF
                                    
    1. 在standalone.xml配置文件中添加system-properties： 
    <system-properties>        <property name="org.apache.cxf.logging.enabled" value=&
    
                                
    • 
                                
  • 【Hadoop三】Centos7_x86_64部署Hadoop集群之编译Hadoop源代码
                                    bit1129
centos
                                    
      编译必需的软件 
 
 Firebugs3.0.0 
 Maven3.2.3 
 Ant 
 JDK1.7.0_67 
 protobuf-2.5.0 
 Hadoop 2.5.2源码包 
 
  
  
  
 
 Firebugs3.0.0 
 
  
http://sourceforge.jp/projects/sfnet_findbug
    
                                
    • 
                                
  • struts2验证框架的使用和扩展
                                    白糖_
框架xmlbeanstruts正则表达式
                                    
    struts2能够对前台提交的表单数据进行输入有效性校验，通常有两种方式： 
1、在Action类中通过validatexx方法验证，这种方式很简单，在此不再赘述； 
2、通过编写xx-validation.xml文件执行表单验证，当用户提交表单请求后，struts会优先执行xml文件，如果校验不通过是不会让请求访问指定action的。 
本文介绍一下struts2通过xml文件进行校验的方法并说
    
                                
    • 
                                
  • 记录-感悟
                                    braveCS
感悟
                                    
    再翻翻以前写的感悟，有时会发现自己很幼稚，也会让自己找回初心。 
  
2015-1-11  1. 能在工作之余学习感兴趣的东西已经很幸福了； 
2. 要改变自己，不能这样一直在原来区域，要突破安全区舒适区，才能提高自己，往好的方面发展； 
3. 多反省多思考；要会用工具，而不是变成工具的奴隶； 
4. 一天内集中一个定长时间段看最新资讯和偏流式博
    
                                
    • 
                                
  • 编程之美-数组中最长递增子序列
                                    bylijinnan
编程之美
                                    
    
import java.util.Arrays;
import java.util.Random;

public class LongestAccendingSubSequence {

	/**
	 * 编程之美 数组中最长递增子序列 
	 * 书上的解法容易理解
	 * 另一方法书上没有提到的是，可以将数组排序（由小到大）得到新的数组，
	 * 然后求排序后的数组与原数
    
                                
    • 
                                
  • 读书笔记5
                                    chengxuyuancsdn
重复提交struts2的token验证
                                    
    1、重复提交 
2、struts2的token验证 
3、用response返回xml时的注意 
 
1、重复提交 
(1)应用场景 
(1-1)点击提交按钮两次。 
(1-2)使用浏览器后退按钮重复之前的操作，导致重复提交表单。 
(1-3)刷新页面 
(1-4)使用浏览器历史记录重复提交表单。 
(1-5)浏览器重复的 HTTP 请求。 
(2)解决方法 
(2-1)禁掉提交按钮 
(2-2)
    
                                
    • 
                                
  • [时空与探索]全球联合进行第二次费城实验的可能性
                                    comsci

                                    
     
 
     二次世界大战前后,由爱因斯坦参加的一次在海军舰艇上进行的物理学实验 -费城实验 
  至今给我们大家留下很多迷团..... 
 
     关于费城实验的详细过程,大家可以在网络上搜索一下,我这里就不详细描述了 
 
     在这里,我的意思是,现在
    
                                
    • 
                                
  • easy connect 之 ORA-12154: TNS: 无法解析指定的连接标识符
                                    daizj
oracleORA-12154
                                    
    用easy connect连接出现“tns无法解析指定的连接标示符”的错误，如下： 
C:\Users\Administrator>sqlplus username/[email protected]:1521/orcl 
SQL*Plus: Release 10.2.0.1.0 – Production on 星期一 5月 21 18:16:20 2012 
Copyright (c) 198
    
                                
    • 
                                
  • 简单排序:归并排序
                                    dieslrae
归并排序
                                    
    
    public void mergeSort(int[] array){
        int temp = array.length/2;
        
        if(temp == 0){
            return;
        }
        
        int[] a = new int[temp];
        int
    
                                
    • 
                                
  • C语言中字符串的\0和空格
                                    dcj3sjt126com
c
                                    
       \0 为字符串结束符，比如说： 
                      abcd (空格)cdefg； 
存入数组时，空格作为一个字符占有一个字节的空间，我们
    
                                
    • 
                                
  • 解决Composer国内速度慢的办法
                                    dcj3sjt126com
Composer
                                    
    用法： 
有两种方式启用本镜像服务： 
1 将以下配置信息添加到 Composer 的配置文件 config.json 中（系统全局配置）。见“例1” 
2 将以下配置信息添加到你的项目的 composer.json 文件中（针对单个项目配置）。见“例2” 
为了避免安装包的时候都要执行两次查询，切记要添加禁用 packagist 的设置，如下      1   2   3   4   5    
    
                                
    • 
                                
  • 高效可伸缩的结果缓存
                                    shuizhaosi888
高效可伸缩的结果缓存
                                    
    /**
 * 要执行的算法，返回结果v
 */
public interface Computable<A, V> {
	public V comput(final A arg);

}
 
  
/**
 * 用于缓存数据
 */
public class Memoizer<A, V> implements Computable<A, 
    
                                
    • 
                                
  • 三点定位的算法
                                    haoningabc
c算法
                                    
    三点定位， 
已知a,b,c三个顶点的x,y坐标 
和三个点都z坐标的距离，la，lb,lc 
 
求z点的坐标 
原理就是围绕a,b,c 三个点画圆，三个圆焦点的部分就是所求 
但是，由于三个点的距离可能不准，不一定会有结果， 
所以是三个圆环的焦点，环的宽度开始为0，没有取到则加1 
运行 
gcc -lm test.c 
test.c代码如下 
 

#include "stdi
    
                                
    • 
                                
  • epoll使用详解
                                    jimmee
clinux服务端编程epoll
                                    
    epoll - I/O event notification facility在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linu
    
                                
    • 
                                
  • Hibernate对Enum的映射的基本使用方法
                                    linzx0212
enumHibernate
                                    
      
枚举 
  
/**
 * 性别枚举
 */
public enum Gender {

    MALE(0), FEMALE(1), OTHER(2);

    private Gender(int i) {
        this.i = i;
    }

    private int i;

    public int getI
    
                                
    • 
                                
  • 第10章 高级事件（下）
                                    onestopweb
事件
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • 孙子兵法
                                    roadrunners
孙子兵法
                                    
    始计第一 
 
孙子曰： 
兵者，国之大事，死生之地，存亡之道，不可不察也。 
故经之以五事，校之以计，而索其情：一曰道，二曰天，三曰地，四曰将，五 
曰法。道者，令民于上同意，可与之死，可与之生，而不危也；天者，阴阳、寒暑 
、时制也；地者，远近、险易、广狭、死生也；将者，智、信、仁、勇、严也；法 
者，曲制、官道、主用也。凡此五者，将莫不闻，知之者胜，不知之者不胜。故校 
之以计，而索其情，曰
    
                                
    • 
                                
  • MySQL双向复制
                                    tomcat_oracle
mysql
                                    
    本文包括: 
 
  主机配置  
  从机配置  
  建立主-从复制  
  建立双向复制  
 
  背景 
按照以下简单的步骤: 
参考一下： 
 
  在机器A配置主机(192.168.1.30)  
  在机器B配置从机(192.168.1.29)  
  我们可以使用下面的步骤来实现这一点  
 
  
步骤1：机器A设置主机 
 
  在主机中打开配置文件 , 
    
                                
    • 
                                
  • zoj 3822 Domination(dp)
                                    阿尔萨斯
Mina
                                    
     题目链接：zoj 3822 Domination 
 题目大意：给定一个N∗M的棋盘，每次任选一个位置放置一枚棋子，直到每行每列上都至少有一枚棋子，问放置棋子个数的期望。 
 解题思路：大白书上概率那一张有一道类似的题目，但是因为时间比较久了，还是稍微想了一下。dp[i][j][k]表示i行j列上均有至少一枚棋子，并且消耗k步的概率（k≤i∗j）,因为放置在i+1~n上等价与放在i+1行上，同理
    
                                
    •