chaozhung
chaozhung

查内存泄漏神器，LeakCanray原来是这样工作的

原文地址 原文地址

 

/   原理   /

 

  1. Activity onDestroy之后将它放在一个WeakReference。

  2. 这个WeakReference关联到一个ReferenceQueue。

  3. 查看ReferenceQueue是否存在Activity的引用。

  4. 如果该Activity泄露了，Dump出heap信息，然后再去分析泄露路径。

 

知识要点

 

软引用&弱引用

 

软引用(SoftReference)和弱引用(WeakReference)都继承Reference。

 

  • 软引用：当一个对象只有软引用存在时，系统内存不足时会被gc回收。

  • 弱引用：当一个对象只有弱引用存在时，随时被gc回收。

 

对象被回收后，Java虚拟机就会把这个引用加入到与之关联的引用队列中。

 

 

//java.lang.ref.Reference.java
 public abstract class Reference {
   ...
   volatile T referent;
   final ReferenceQueue queue;
   ...
   Reference(T referent) {
       this(referent, null);
   }
   Reference(T referent, ReferenceQueue queue) {
       this.referent = referent;
       this.queue = queue;
   }
   ...
   /**
    * 

 This method is invoked only by Java code; when the garbage collector
    * enqueues references it does so directly, without invoking this method.
    *(这个方法仅会被java代码调用，当GC时会直接把referent添加到queue引用队列)
    *
    */
   public boolean enqueue() {
      return queue != null && queue.enqueue(this);
   }
 }

 

简单实例:

 

 

public class RefTest {
     public static void main(String[] args) {
         //user为强引用
         User user = new User("张三", 18);

 

 

//创建弱引用并关联引用队列
      ReferenceQueue queue = new ReferenceQueue<>();
      WeakReference weakReference = new WeakReference(user,queue);

      //置空强引用，触发GC
      user=null;
      Runtime.getRuntime().gc();
      try {
          Thread.sleep(100);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      //强制系统回收已经没有强引用的对象
      System.runFinalization();

      WeakReference pollRef=null;
      //弹出对列的引弱用
      while ((pollRef = (WeakReference) queue.poll()) != null) {
        System.out.println("pollRef的内存地址:"+pollRef.toString());
        System.out.println("pollRef等于weakReference？:"+weakReference.equals(pollRef));
      }
  }

 

运行结果（注意内存地址是由JVM分配的，故可能有所差异）:

 

pollRef的内存地址:java.lang.ref.WeakReference@610455d6

 

pollRef等于weakReference？:true

 

Java垃圾回收(GC)

 

在Java中垃圾判断方法是可达性分析算法，这个算法的基本思路是通过一系列的"GC Root"的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径成为引用链，当一个对象到GC Root没有任何引用链相连时，则证明此对象是不可用的。

 

GC Root的对象包括以下几种：

 

  1. 虚拟机栈中引用的对象。

  2. 方法区中类静态属性引用的对象。

  3. 方法区中常量引用的对象。

  4. 本地方法栈中JNI引用的对象。

 

就算一个对象，通过可达性分析算法分析后，发现其是『不可达』的，也并不是非回收不可的。

 

一般情况下，要宣告一个对象死亡，至少要经过两次标记过程：

 

1、经过可达性分析后，一个对象并没有与GC Root关联的引用链，将会被第一次标记和筛选。筛选条件是此对象有没有必要执行finalize()方法。如果对象没有覆盖finalize()方法，或者已经执行过了。那就认为他可以回收了。如果有必要执行finalize()方法，那么将会把这个对象放置到F-Queue的队列中，等待执行。

 

2、虚拟机会建立一个低优先级的Finalizer线程执行F-Queue里面的对象的finalize()方法。如果对象在finalize()方法中可以『拯救』自己，那么将不会被回收，否则，他将被移入一个即将被回收的ReferenceQ

 

/   源码分析  /

 

首先在gradle引入依赖

 

 

debugImplementation 'com.squareup.leakcanary:leakcanary-android:1.6.3'
    releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.3'
    debugImplementation 'com.squareup.leakcanary:leakcanary-support-fragment:1.6.3'

  ![Leakcanary监听泄露流程]

 

查内存泄漏神器，LeakCanray原来是这样工作的_第1张图片

 

Application启动时注册Activity生命周期监听

 

LeakCanary在Application初始化，代码如下:

 

 

public class BaseApplication extends Application {
      @Override
      public void onCreate() {
          super.onCreate();
          //检查当前进程是否在HeapAnalyzerService所属进程
          if (LeakCanary.isInAnalyzerProcess(this)) {
            return;
          }
        //安装泄露检测
        LeakCanary.install(this);
      }
  }

 

首先调用isInAnalyzerProcess()来判断当前进程是否为HeapAnalyzerService运行的进程。这个方法回调用LeakCanaryInternals.isInServiceProcess()通过PackageManager、ActivityManager以及android.os.Process来判断当前进程是否为HeapAnalyzerService运行的进程，这样子做的目的是不影响主进程的使用。

 

下面是debug生成的AndroidManifest.xml，可以在run应用之后再app/build/intermediates/instant_app_manifest/debug/查看。

 

 

  
         android:name="com.squareup.leakcanary.internal.HeapAnalyzerService"
      android:enabled="false"
      android:process=":leakcanary" />
  
         android:name="com.squareup.leakcanary.DisplayLeakService"
      android:enabled="false"
      android:process=":leakcanary" />
  
         android:name="com.squareup.leakcanary.internal.DisplayLeakActivity"
      android:enabled="false"
      android:icon="@mipmap/leak_canary_icon"
      android:label="@string/leak_canary_display_activity_label"
      android:process=":leakcanary"
      android:taskAffinity="com.squareup.leakcanary.com.pengguanming.studydemo"
      android:theme="@style/leak_canary_LeakCanary.Base" >
      
          
          
      
  

 

注意上面关于LeakCanary的组件的android:enabled=false,android:enabled表示是否能够实例化该应用程序的组件，如果为true，每个组件的enabled属性决定那个组件是否可以被 enabled。如果为false，它覆盖组件指定的值；所有组件都是disabled。

 

这里回过来看install()方法，它调用返回RefWatcher对象，这个对象通过Application注册了Activity的生命周期监听、通过Activity注册监听Fragment的生命周期,且用到了leakcanary-support-fragment包，兼容了v4的fragment。

 

 

public static RefWatcher install(Application application) {
    return refWatcher(application).listenerServiceClass(DisplayLeakService.class)
        .excludedRefs(AndroidExcludedRefs.createAppDefaults().build())//默认过滤一些系统bug造成的内存泄露
        .buildAndInstall();
  }

 

值得注意的是LeakCanary.refWatcher(application)返回的是一个AndroidRefWatcherBuilder对象，下面看看它的buildAndInstall()：

 

 

 xxxxxxxxxx 
if (LeakCanaryInternals.installedRefWatcher != null) {  
    throw new UnsupportedOperationException("buildAndInstall()
 should only be called once.");   
 }    
RefWatcher refWatcher = build();    
if (refWatcher != DISABLED) {   
   //判断是否开启内存泄露提示      
if (enableDisplayLeakActivity) {        LeakCanaryInternals.setEnabledAsync(context, DisplayLeakActivity.class, true);  
    }     
 //判断是否开启Activity内存泄露检测    
  if (watchActivities) {     
   ActivityRefWatcher.install(context, refWatcher);   
   }      
//判断是否开启Fragment内存泄露检测    
  if (watchFragments) {        FragmentRefWatcher.Helper.install(context, refWatcher);    
  }  
  }    //复制给全局静态变量，防止二次调用    LeakCanaryInternals.installedRefWatcher = refWatcher; 
   return refWatcher;

 

首先判断refWatcher是否已被初始，build()创建RefWatcher对象,然后判断这对象是不是RefWatch是否可用，若可用则执行下面操作：

 

检测DisplayLeakActivity是否可用，若不可用则调用LeakCanaryInternals.setEnabledAsync()调用AsyncTask.THREAD_POOL_EXECUTOR这个静态异步线程池执行PackageManager.setComponentEnabledSetting()将这个Activity设置为可用。PackageManager.setComponentEnabledSetting()是IPC的阻塞操作，故作异步处理。

 

判断是否开启Activity内存泄露检测，若没则调用ActivityRefWatcher.install()会创建ActivityRefWatcher对象然后通过Application注册Activity的生命周期监听。

 

判断是否开启Fragment内存泄露检测，若没则调用FragmentRefWatcher.Helper.install()，通过Activity注册监听Fragment的生命周期，且用到了leakcanary-support-fragment包，兼容了v4的fragment。

 

监听Activity/Fragment的销毁

 

上面提到Activity和Fragment的生命周期监听，这里首先看看监听Activity的代码：

 

 

//ActivityRefWatcher.java
public static void install(@NonNull Context context, @NonNull RefWatcher refWatcher) {
    Application application = (Application) context.getApplicationContext();
    ActivityRefWatcher activityRefWatcher = new ActivityRefWatcher(application, refWatcher);
    application.registerActivityLifecycleCallbacks(activityRefWatcher.lifecycleCallbacks);
  }

 

上面通过Application注册了ActivityRefWatcher成员lifecycleCallbacks监听Activity生命周期回调，lifecycleCallbacks是继承Application.ActivityLifecycleCallbacks的抽想类，这样就完成了Activity销毁时监听监听回调，并执行Activity内存泄露检测操作。下面看看它的代码实现:

 

 

private final Application.ActivityLifecycleCallbacks lifecycleCallbacks =
  new ActivityLifecycleCallbacksAdapter() {
    @Override public void onActivityDestroyed(Activity activity) {
      refWatcher.watch(activity);
    }
};

 

现在再来看看监听Fragment的代码：

 

 

//FragmentRefWatcher.Helper.install()
public static void install(Context context, RefWatcher refWatcher) {
      List fragmentRefWatchers = new ArrayList<>();
      if (SDK_INT >= O) {
        //添加兼容android O的Fragment泄露检测
        fragmentRefWatchers.add(new AndroidOFragmentRefWatcher(refWatcher));
      }
      //添加通过反射构造兼容android O以下的Fragment泄露检测
      try {
        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) {
      }
      if (fragmentRefWatchers.size() == 0) {
        return;
      }
      Helper helper = new Helper(fragmentRefWatchers);
      //注册监听Activity生命周期回调
      Application application = (Application) context.getApplicationContext();
      application.registerActivityLifecycleCallbacks(helper.activityLifecycleCallbacks);
    }

 

上面代码实现和监听Activity生命周期有所差异，首先创建FragmentRefWatcher的容器，判断SDK版本是否大于等于Android O，若大于等于则创建AndroidOFragmentRefWatche加入容器，然后在通过反射创建SupportFragmentRefWatcher也加入到容器中，之后创建Helper并通过Application注册了Helper成员activityLifecycleCallbacks监听Activity的生命周期，但它仅监听Activity的创建，下面来看看它的代码:

 

 

private final Application.ActivityLifecycleCallbacks activityLifecycleCallbacks =
        new ActivityLifecycleCallbacksAdapter() {
          @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            for (FragmentRefWatcher watcher : fragmentRefWatchers) {
              watcher.watchFragments(activity);
            }
          }
      };

 

通过上面的代码可以知道，这个activityLifecycleCallbacks在Activity创建时，遍历之前FragmentRefWatcher的list并调用实例中的watchFragments(),list只有两个对象：SupportFragmentRefWatcher(兼容android O以下)和AndroidOFragmentRefWatcher(兼容android O+引入了fragment的生命周期，用户不需要在onDestroy中自行调用)，它们两实现差不多，这里只看SupportFragmentRefWatcher代码：

 

 

class SupportFragmentRefWatcher implements FragmentRefWatcher {
 ...
  private final FragmentManager.FragmentLifecycleCallbacks fragmentLifecycleCallbacks =
      new FragmentManager.FragmentLifecycleCallbacks() {
        @Override public void onFragmentViewDestroyed(FragmentManager fm, Fragment fragment) {
          //在Fragment的View销毁时检测泄露
          View view = fragment.getView();
          if (view != null) {
            refWatcher.watch(view);
          }
        }

        @Override public void onFragmentDestroyed(FragmentManager fm, Fragment fragment) {
          //在Fragment实例销毁时检测泄露
          refWatcher.watch(fragment);
        }
      };

  @Override public void watchFragments(Activity activity) {
    if (activity instanceof FragmentActivity) {
      //注册supportFragment生命周期监听
      FragmentManager supportFragmentManager =
          ((FragmentActivity) activity).getSupportFragmentManager();
      supportFragmentManager.registerFragmentLifecycleCallbacks(fragmentLifecycleCallbacks, true);
    }
  }
}

 

到watchFragments()这里发现这才和监听Activity生命周期相似,通过Activity获取FragmentManager注册成员FragmentLifecycleCallbacks监听Fragment销毁生命周期，然后进行内存泄露检测操作。

 

检测对象弱引用关联引用队列

 

在之前得知在Activity和Fragment销毁时都会拿调用RefWatch.watch()方法，在此之前先了解一下RefWatch对象:

 

 

/
*@param WatchExecutor 用于执行检测内存的线程控制器
*@param DebuggerControl 查询是否正在debug中，若正在debug会不执行内存泄露的检测判断
*@param GcTrigger 用来触发垃圾回收的，上面的线程控制器5s后观察有泄露，不算泄露，必须垃圾回收后，再去观察一次。所以最多会观察两次。第一次是5s后观察，第二次是5s后在垃圾回收后观察
*@param HeapDump dump出内存泄露的heap堆文件
*@param HeapDump.Listener 产生heap文件的回调
*@param ExcludeRefs 过滤掉的内存泄露
/ 
RefWatcher(WatchExecutor watchExecutor, DebuggerControl debuggerControl, GcTrigger gcTrigger,
      HeapDumper heapDumper, HeapDump.Listener heapdumpListener, ExcludedRefs excludedRefs) {
    this.watchExecutor = checkNotNull(watchExecutor, "watchExecutor");
    this.debuggerControl = checkNotNull(debuggerControl, "debuggerControl");
    this.gcTrigger = checkNotNull(gcTrigger, "gcTrigger");
    this.heapDumper = checkNotNull(heapDumper, "heapDumper");
    this.heapdumpListener = checkNotNull(heapdumpListener, "heapdumpListener");
    this.excludedRefs = checkNotNull(excludedRefs, "excludedRefs");
    //持有待检测内存泄露引用的key，这里使用CopyOnWriteArraySet解决并发读写问题
    retainedKeys = new CopyOnWriteArraySet<>();
    //引用队列，弱引用或软引用被gc回收后会达到此队列
    queue = new ReferenceQueue<>();
  }

 

上面代码让我们有个大概认识，这小节只关注retainedKeys和queue成员变量就够了，其他成员变量会在之后分析到，我们先看看RefWatch.watch():

 

 

public void watch(Object watchedReference, String referenceName) {
    if (this == DISABLED) {
      return;
    }
    checkNotNull(watchedReference, "watchedReference");
    checkNotNull(referenceName, "referenceName");
    //检查泄露开始时间
    final long watchStartNanoTime = System.nanoTime();
    //为引用生成唯一的key
    String key = UUID.randomUUID().toString();
    retainedKeys.add(key);
    //创建一个弱引用
    final KeyedWeakReference reference =
        new KeyedWeakReference(watchedReference, key, referenceName, queue);
    //开启异步线程分析弱引用
    ensureGoneAsync(watchStartNanoTime, reference);
  }

 

首先会判断当前RefWatch是否可用，然后对检测对象和对应的引用标识字符串判空，生成检查泄露开始时间，接下来为引用生成唯一的key并添加到retainedKeys，然后创建KeyedWeakReference对象，开启异步线程分析弱引用。这里看看KeyedWeakReference代码：

 

 

final class KeyedWeakReference extends WeakReference {
  public final String key;
  public final String name;

  KeyedWeakReference(Object referent, String key, String name,
      ReferenceQueue referenceQueue) {
    super(checkNotNull(referent, "referent"), checkNotNull(referenceQueue, "referenceQueue"));
    this.key = checkNotNull(key, "key");
    this.name = checkNotNull(name, "name");
  }
}

 

从上面可以看出KeyedWeakReference封装了引用唯一的key和引用标识字符串，并将检测对象的弱引用关联到RefWatch的引用队列。

 

等待主线程空闲

 

从上一小节看到RefWatch.ensureGoneAsync()，下面看看代码实现:

 

 

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

 

有上面代码看出将泄露检测转移到WatchExecutor，而它的实现是AndroidWatchExecutor，接下来看看它的代码：

 

 

public final class AndroidWatchExecutor implements WatchExecutor {
  static final String LEAK_CANARY_THREAD_NAME = "LeakCanary-Heap-Dump";//子线程名称
  private final Handler mainHandler;//绑定主线程的Handler
  private final Handler backgroundHandler;//绑定子线程的Handler
  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将操作切换到主线程
    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.（这里一定要在主线程调用）
    //添加主线程空闲回调监听执行postToBackgroundWithDelay()
    Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
      @Override public boolean queueIdle() {
        postToBackgroundWithDelay(retryable, failedAttempts);
        return false;
      }
    });
  }

  private void postToBackgroundWithDelay(final Retryable retryable, final int failedAttempts) {
    //指数2增长的重试数，最大值不超过maxBackoffFactor
    long exponentialBackoffFactor = (long) Math.min(Math.pow(2, failedAttempts), maxBackoffFactor);
    //延迟执行的时间
    long delayMillis = initialDelayMillis * exponentialBackoffFactor;
    //切换到后台子线程执行
    backgroundHandler.postDelayed(new Runnable() {
      @Override public void run() {
        Retryable.Result result = retryable.run();
        //如果返回值为RETRY时，会再次延时再次尝试执行。延迟初始时间为5s，以后每次重试时间x2
        if (result == RETRY) {
          postWaitForIdle(retryable, failedAttempts + 1);
        }
      }
    }, delayMillis);
  }
}

 

AndroidWatchExecutor的构造方法会创建主线程和和后台子线的Handler，并初始化切换到子线程Handler的最大延迟时间maxBackoffFactor和初始化时间initialDelayMillis，maxBackoffFactor值为Long.MAX_VALUE / initialDelayMillis，initialDelayMillis值为5（因为AndroidWatchExecutor是被AndroidRefWatcherBuilder.defaultWatchExecutor()创建）。

 

execute()里的无论waitForIdle()还是postWaitForIdle()，都是需要切换到主线程执行，而且postWaitForIdle()最终切换到waitForIdle()。

 

waitForIdle()监听主线程Handler消息队列空闲，只要主线程空闲就会执行postToBackgroundWithDelay()操作。

 

postToBackgroundWithDelay()会就首先根据重试次数计算延迟执行的时间，然后延迟切换到子线程的Handler操作，如果Retryable.run()返回Result.RETRY时，会执行postWaitForIdle()继续等待主线程再次空闲。

 

Retryable.run()在之前RefWatcher.ensureGoneAsync()被调用，而Retryable.run()的返回值由RefWatcher.ensureGoneAsync()返回，ensureGoneAsync()在以下的情况会返回Result.RETRY：

 

  1. debug模式启动时。

  2. 创建dumpHeap文件失败时。

  3. 5s后UI线程未空闲时。

 

泄露判断

 

RefWatch.ensureGone()主要是判断内存泄露，下面看看它的实现：

 

 

Retryable.Result ensureGone(final KeyedWeakReference reference, final long watchStartNanoTime) {
    long gcStartNanoTime = System.nanoTime();
    //计算watch方法到gc垃圾回收的时长
    long watchDurationMs = NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);
    //尝试移除已经到达引用队列的弱引用
    removeWeaklyReachableReferences();
    //判断是否在debug
    if (debuggerControl.isDebuggerAttached()) {
      // The debugger can create false leaks. (debug可以创造错误的内存泄露)
      return RETRY;
    }
    if (gone(reference)) {//若当前对象已经可达了，即不会造成你内存泄露
      return DONE;
    }
    //手动gc，确保引用对象是否真的被回收了。因为在dump内存信息之前提示内存泄露的时候，希望系统经过充分gc垃圾回收，而不存在任何的误判，对leakcanary容错性的考虑
    gcTrigger.runGc();
    //清除已经到达引用队列的弱引用
    removeWeaklyReachableReferences();
    if (!gone(reference)) {//此时对象还没到达对列，代表已经内存泄露了
      long startDumpHeap = System.nanoTime();
      long gcDurationMs = NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);
      //dump出内存泄露的heap文件,这里可能触发GC
      File heapDumpFile = heapDumper.dumpHeap();
      if (heapDumpFile == RETRY_LATER) {
        // Could not dump the heap.(不能dump heap堆文件)
        return RETRY;
      }
      //dump heap文件的时间计算
      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);
    }
    return DONE;
  }

 

上面代码执行如下：

 

在之前的RefWatch.watch()里生成了检测引用对象的UUID的key并关联了弱引用KeyedWeakReference对象，弱引用与ReferenceQueue联合使用，如果弱引用关联的对象被回收，则会把这个弱引用加入到ReferenceQueue中。

 

removeWeaklyReachableReferences()尝试移除已经到达引用队列的弱引用，会对应删除KeyedWeakReference的数据。如果这个引用继续存在，那么就说明没有被回收。

 

gone()查看retainedKeys是否包含KeyedWeakReference的唯一key。

 

手动触发GC操作，gcTrigger中封装了gc操作的代码,首先会调用Runtime.getRuntime().gc()以触发系统gc操作，然后当前后台子线程sleep 100毫秒，最后调用System.runFinalization()强制系统回收没有引用的队形，这样子确保引用对象是否真的被回收了。因为在dump内存信息之前提示内存泄露的时候，希望系统经过充分gc垃圾回收，而不存在任何的误判，这是对leakcanary容错性的考虑。

 

再次移除不可达引用，如果引用存在了，都没有被回收则判定内存泄露。

 

判定泄露后调用AndroidHeapDumper.dump()，首先通过LeakDirectoryProvider的实现类DefaultLeakDirectoryProvider为.prof文件创建File，若文件创建失败也会返回RETRY_LATER让之前的AndroidWatchExecutor.execute()等待下次主线程空闲执行，它最多创建7个文件，数目超过后，删除最早创建的文件，所有文件默认保存在Download文件夹下；然后利用CountDownLatch阻塞当前后台子线程5秒并监听主线程是否空闲，若不空闲则返回RETRY_LATER，若空闲则调用android.os.Debug.dumpHprofData()生成.prof文件。

 

调用HeapDump.Listener分析刚生成的.prof文件。

 

泄露信息分析

 

既然判断了内存泄露，那么接下来泄露信息分析，找出泄露的对象的引用路径。

 

ServiceHeapDumpListener是HeapDump.Listener的实现类，在RefWatch.ensureGone()中调用了它的analyze():

 

 

@Override 

public void analyze(HeapDump heapDump) {
    checkNotNull(heapDump, "heapDump");
    HeapAnalyzerService.runAnalysis(context, heapDump, listenerServiceClass);
  }

 

HeapAnalyzerService继承抽象类ForegroundService，而IntentService继承IntentService,它的runAnalysis()会回调onHandleIntent()：

 

 

 public final class HeapAnalyzerService extends ForegroundService
    implements AnalyzerProgressListener {
  ...
  public static void runAnalysis(Context context, HeapDump heapDump,
      Class listenerServiceClass) {
    //开启Service实例化
    setEnabledBlocking(context, HeapAnalyzerService.class, true);
    setEnabledBlocking(context, listenerServiceClass, true);
    //启动前台服务
    Intent intent = new Intent(context, HeapAnalyzerService.class);
    intent.putExtra(LISTENER_CLASS_EXTRA, listenerServiceClass.getName());
    intent.putExtra(HEAPDUMP_EXTRA, heapDump);
    ContextCompat.startForegroundService(context, intent);
  }
  ...
  @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 heapAnalyzer =
        new HeapAnalyzer(heapDump.excludedRefs, this, heapDump.reachabilityInspectorClasses);
    //检查内存泄露
    AnalysisResult result = heapAnalyzer.checkForLeak(heapDump.heapDumpFile, heapDump.referenceKey,
        heapDump.computeRetainedHeapSize);
    //回调结果显示
    AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);
  }
}

 

HeapAnalyzer的checkForLeak():是leakcannary最核心的方法

 

 

  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 {
      //封装成MemoryMappedFileBuffer对象
      listener.onProgressUpdate(READING_HEAP_DUMP_FILE);
      HprofBuffer buffer = new MemoryMappedFileBuffer(heapDumpFile);
      //传进HprofParser解析器
      HprofParser parser = new HprofParser(buffer);
      //装换成Snapshot内存快照对象
      listener.onProgressUpdate(PARSING_HEAP_DUMP);
      Snapshot snapshot = parser.parse();
      //去重复路径结果
      listener.onProgressUpdate(DEDUPLICATING_GC_ROOTS);
      deduplicateGcRoots(snapshot);
      //根据要检测的key查询解析结果中是否有需要的对象
      listener.onProgressUpdate(FINDING_LEAKING_REF);
      Instance leakingRef = findLeakingReference(referenceKey, snapshot);
      // False alarm, weak reference was cleared in between key check and heap dump.（误报，弱引用在对应的KeyedWeakReference检查和heap堆文件期间被清除）
      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库(一个heap prof堆文件分析库)，将hprof文件解析成内存快照Snapshot对象进行分析。

https://github.com/square/haha

 

deduplicateGcRoots()使用jetBrains的THashMap(THashMap的内存占用量比HashMap小)做中转，去掉snapshot中GCRoot的重复路径，以减少内存压力。

 

找出泄露对象并找出泄露对象的最短路劲。

 

HeapAnalyzer.findLeakingReference()主要作用是找出泄露对象：

 

 

 private Instance findLeakingReference(String key, Snapshot snapshot) {
   //通过查找的弱引用创建ClassOb对象
    ClassObj refClass = snapshot.findClass(KeyedWeakReference.class.getName());
    List keysFound = new ArrayList<>();
    for (Instance instance : refClass.getInstancesList()) {
      List values = classInstanceValues(instance);
      String keyCandidate = asString(fieldValue(values, "key"));
      if (keyCandidate.equals(key)) {//key值相等则找到内存泄露对象
        return fieldValue(values, "referent");
      }
      keysFound.add(keyCandidate);
    }
    throw new IllegalStateException(
        "Could not find weak reference with key " + key + " in " + keysFound);
  }

 

  1. 在snpashot内存快照中找到泄露对象的弱引用。

  2. 遍历这个对象所有实例。

  3. 若这个key值和最开始定义封装KeyedWeakReference的key值相同，那么返回这个泄露对象。

 

HeapAnalyer.findLeakTract()主要作用是找到最短泄露路径，计算泄露大小作为结果反馈：

 

 

private AnalysisResult findLeakTrace(long analysisStartNanoTime, Snapshot snapshot,
      Instance leakingRef, boolean computeRetainedSize) {
    //分析snpashot内存快照找出内存泄露的点，判断依据是GCRoot
    listener.onProgressUpdate(FINDING_SHORTEST_PATH);
    ShortestPathFinder pathFinder = new ShortestPathFinder(excludedRefs);
    //查找泄露的最短引用链，这里只关注GCRoot的两种类型：1.静态；2.被其他线程使用并且其他线程正在运行没有结束
    ShortestPathFinder.Result result = pathFinder.findPath(snapshot, leakingRef);
    String className = leakingRef.getClassObj().getClassName();
    // False alarm, no strong reference path to GC Roots.（误报，没有强引用的GCRoots）
    if (result.leakingNode == null) {
      return noLeak(className, since(analysisStartNanoTime));
    }
    listener.onProgressUpdate(BUILDING_LEAK_TRACE);
    //生成内存泄露调用栈 
    LeakTrace leakTrace = buildLeakTrace(result.leakingNode);
    //计算内存泄露空间大小
    long retainedSize;
    if (computeRetainedSize) {
      listener.onProgressUpdate(COMPUTING_DOMINATORS);
      // Side effect: computes retained size.
      snapshot.computeDominators();
      Instance leakingInstance = result.leakingNode.instance;
      retainedSize = leakingInstance.getTotalRetainedSize();
      // TODO: check O sources and see what happened to android.graphics.Bitmap.mBuffer
      if (SDK_INT <= N_MR1) {
        listener.onProgressUpdate(COMPUTING_BITMAP_SIZE);
        retainedSize += computeIgnoredBitmapRetainedSize(snapshot, leakingInstance);
      }
    } else {
      retainedSize = AnalysisResult.RETAINED_HEAP_SKIPPED;
    }
    return leakDetected(result.excludingKnownLeaks, className, leakTrace, retainedSize,
        since(analysisStartNanoTime));
  }

 

泄露信息展示

 

HeapAnalyzerService.onHandleIntentInForeground():

 

 

...
//HeapAnalyzerService.java
//回调结果显示
AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);

 

AbstractAnalysisResultService.sendResultToListener()通过调用AnalyzedHeap.save()将之前的.prof文件保存为.result文件，然后将.result文件路径通过intent传到DisplayLeakService(继承AbstractAnalysisResultService，而AbstractAnalysisResultService是继承ForegroundService)。

 

这里首先调用父类AbstractAnalysisResultService.onHandleIntentInForeground()通过AnalyzedHeap.load()将.result文件生成AnalyzedHeap对象，之后调用onHeapAnalyzed()将AnalyzedHeap的信息通过Notification展示。

 

DisplayLeakActivity是平时用到的通过桌面入口进入的泄漏信息查看Activity在AndroidRefWatcherBuilder.buildAndInstall()被开启实例化

 

 

//DisplayLeakActivity.java
  @Override protected void onResume() {
    super.onResume();
    LoadLeaks.load(this, getLeakDirectoryProvider(this));
  }

 

在onResume的时候使用了LoadLeaks（实现了Runnable接口），并传入一个Provider，这个Provider就是上面创建.result文件时所用到的DefaultLeakDirectoryProvider，而在load方法主要在线程池执行是读取.result文件，然后通过UI Handler将读取的信息更新ui中。

 

/   学习借鉴   /

 

使用DownCountLatch同步主线程和子线程。

 

这里使用CopyOnWriteArraySet解决并发读写问题。

 

构建者模式，代码简洁、清新，链式调用创建对象，参考RefWatcherBuilder对象。

 

MessageQueue.addIdleHandler(IdleHandler handler)，监听线程空闲。

 

手动GC，参考GCTrigger.runGc()。

 

Reference.watch()本质上是可以监控任意对象类型的，关键在于监控的时机，像activity、service、fragmen是有生命周期的，可以在ondestroy时开始监控，其他的对象类型用户可以选择合适的时机调用该方法进行监控。注意如果首页的Activity一直不销毁（onDestroy）那么将一直无法检测到首页的调用栈的内存泄漏。

 

借助AsyncTask.THREAD_POOL_EXECUTOR静态线程池执行异步任务。

 

/   总结   /

 

LeakCanary的源码设计非常精妙，由于本人水平有限仅给各位提供参考，希望能够抛砖引玉。

你可能感兴趣的:(android,基础知识)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • Rust基础知识 GRKF15 rust开发语言后端
    1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Python入门之Lesson2:Python基础语法 小熊同学哦 Python入门课程python开发语言算法数据结构青少年编程
    目录前言一.介绍1.变量和数据类型2.常见运算符3.输入输出4.条件语句5.循环结构二.练习三.总结前言欢迎来到《Python入门》系列博客的第二课。在上一课中，我们了解了Python的安装及运行环境的配置。在这一课中，我们将深入学习Python的基础语法，这是编写Python代码的根基。通过本节内容的学习，你将掌握变量、数据类型、运算符、输入输出、条件语句等Python编程的基础知识。一.介绍1
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • 【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】 汉子萌萌哒 CCFnoi算法数据结构c++
    一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • Golang语言基础知识点总结 最帅猪猪侠 golang开发语言后端
    Golang语言基础知识点小总结1.go语言有两大类型：值类型：数值类型，bool，string，数组，struct结构体变量直接存储值，内存通常在栈中分配,修改值,不会对源对象产生影响引用类型：指针，slice切片，管道chan，map，interface变量存储的是一个地址，这个地址对应的空间才真正存储数据值，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • go基础知识归纳总结 悟空丶123 golang开发语言后端
    无缓冲的channel和有缓冲的channel的区别？在Go语言中，channel是用来在goroutines之间传递数据的主要机制。它们有两种类型：无缓冲的channel和有缓冲的channel。无缓冲的channel行为：无缓冲的channel是一种同步的通信方式，发送和接收必须同时发生。如果一个goroutine试图通过无缓冲channel发送数据，它会阻塞，直到另一个goroutine从该
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2021-10-03 虫虫新生111
    今天放假的第3天感觉过得好快，总体来说数学做了25道题，里边有几道题还是弄得不清楚，仍然不懂怎么做，不过整体感觉思路比去年要清晰很多，因为有去年的基础，今年还是比较轻松一些。逻辑做了有几道题，6题，错2，有些概念总的是模糊不清，还是要反复的再整理一下概念，以及回头看一下讲的基础知识，把基础的公式弄懂才可以。现在困了睡觉，明天早点起床。
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • 【Python基础】Python迭代器与生成器（两种强大工具） 姑苏老陈 Python编程入门python开发语言python迭代器与生成器
    本文收录于《Python编程入门》专栏，从零基础开始，分享一些Python编程基础知识，欢迎关注，谢谢！文章目录一、前言二、迭代器2.1创建迭代器2.2自定义迭代器2.3处理大型文件三、生成器四、生成器表达式五、实际应用案例5.1数据库查询5.2网络数据流处理六、总结一、前言在Python中，迭代器与生成器是两种非常强大的工具，它们可以帮助我们有效地处理大量数据，特别是在需要逐个访问元素的情况下。
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • CMU 15-445/645 Lab2-B+Tree Index yyy_3y CMU-15/445b树数据结构CMU15-445数据库
    0.写在前面GitHub同步更新https://github.com/kaniel-outis/CMU15-445Lab2的地址：https://15445.courses.cs.cmu.edu/fall2020/project2/本文主要总结一下在写Lab2需要的基础知识以及Task的解决思路（不公开代码，如果有问题可以留言）。Lab2的主要内容是B+tree的定义和Insert、Delete操
  • SQLite的入门级项目学习记录（二） 深蓝海拓 SQLite学习笔记sqlite学习数据库
    再补充一些基础知识：并行操作的问题1、可以多游标同时运行SQLite，对于同一个连接sqlite3.connect(db_file)，可以同时创建多个游标，每个游标都是独立的，可以执行各自的SQL命令序列。importsqlite3#创建数据库连接conn=sqlite3.connect('example.db')#创建第一个游标cursor1=conn.cursor()cursor1.execu
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 四、模型的下载与使用 梦中星华 AI画图人工智能
    模型的下载与使用在我们已经熟悉的文生图和图生图的基础知识之上，现在是时候选择我们的艺术伙伴——AI模型了。在本篇讲义中，我们将学习掌握模型的下载和安装过程，以及如何在实际创作中灵活调用它们。通过本课程的学习，我们将能够更加自如地驾驭AI绘画工具，让我们的艺术创作更加多元和高效。让我们一起迈出这一步，选择一位能够理解我们创意愿景的AI画家，共同创作出令人赞叹的艺术作品。§1.模型的基本概念与下载\S
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • 如何从大型语言模型(LLM)流式响应 aehrutktrjk 语言模型microsoftajaxpython
    引言随着大型语言模型(LLM)的不断发展,我们不仅能够获得高质量的文本生成结果,还可以实时观察模型生成文本的过程。流式响应允许我们以一种更加交互和动态的方式与LLM进行交互,这在某些应用场景中非常有用。在本文中,我们将探讨如何从LLM流式获取响应。基础知识在开始之前,我们需要了解一些基础概念。所有的LLM都实现了Runnable接口,该接口提供了一些默认实现的标准方法,如invoke、batch、
  • 对股票分析时要注意哪些主要因素？ 会飞的奇葩猪 股票 分析 云掌股吧
    　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。     一、成交量 　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
  • 【Scala十八】视图界定与上下文界定 bit1129 scala
    Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。   隐式参数 首先引入一个泛型函数max，用于取a和b的最大值 def max[T](a: T, b: T) = { if (a > b) a else b }  因为T是未知类型，只有运行时才会代入真正的类型，因此调用a >
  • C语言的分支——Object-C程序设计阅读有感 darkblue086 applec框架cocoa
    自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 Object-C程序设计这本书
  • 去除浏览器对表单值的记忆 周凡杨 html记忆autocompleteform浏览
                                       &n
  • java的树形通讯录 g21121 java
    最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 // 首先取出每个部门的联系人 for (int i = 0; i < depList.size(); i++) { List<Contacts> list = getContactList(depList.get(i
  • Nginx安装部署 510888780 nginxlinux
    Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
  • java servelet异步处理请求 墙头上一根草 ｊａｖａ异步返回ｓｅｒｖｌｅｔ
    servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能，        final AsyncContext ac = request.startAsync(request, response);   ac.s
  • 我的spring学习笔记8-Spring中Bean的实例化 aijuans Spring 3
    在Spring中要实例化一个Bean有几种方法： 1、最常用的（普通方法） <bean id="myBean" class="www.6e6.org.MyBean" /> 使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。 （有构造方法的下个文细说） 2、还
  • 为Mysql创建最优的索引 annan211 mysql索引
    索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。 索引经常会被误解甚至忽略，而且经常被糟糕的设计。 索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比 较好的索引性能要好2个数量级。 1 索引的类型 (1) B-Tree 不出意外，这里提到的索引都是指 B-
  • 日期函数 百合不是茶 oraclesql日期函数查询
      ORACLE日期时间函数大全 TO_DATE格式(以时间:2007-11-02 13:45:25为例) Year: yy two digits 两位年 显示值:07 yyy three digits 三位年 显示值:007
  • 线程优先级 bijian1013 javathread多线程java多线程
    多线程运行时需要定义线程运行的先后顺序。 线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。 实例： package com.bijian.study; /** * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
  • 适配器模式和代理模式的区别 bijian1013 java设计模式
    一.简介        适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。      &nbs
  • 【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件 bit1129 Mybatis3
     SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句， 这些元素包含三方面内容 1. 要执行的SQL语句 2. SQL语句的入参，比如查询条件 3. SQL语句的返回结果
  • oracle大数据表复制备份个人经验 bitcarter oracle大表备份大表数据复制
    前提：    数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。    
  • HTTP加速器varnish安装小记 ronin47 http varnish 加速
    上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！ 苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
  • java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度 bylijinnan java
    public class LongestSymmtricalLength { /* * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。 */ public static void main(String[] args) { Str
  • 学习编程的一点感想 Cb123456 编程感想Gis
           写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目.      本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
  • [能源与安全]美国与中国 comsci 能源
         现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。       在这个大
  • SEMI-JOIN执行计划突然变成HASH JOIN了 的原因分析 cwqcwqmax9 oracle
    甲说： A B两个表总数据量都很大，在百万以上。 idx1  idx2字段表示是索引字段 A B 两表上都有 col1字段表示普通字段 select xxx from A where A.idx1 between mmm and nnn      and exists (select 1 from B where B.idx2 =
  • SpringMVC-ajax返回值乱码解决方案 dashuaifu AjaxspringMVCresponse中文乱码
      SpringMVC-ajax返回值乱码解决方案   一：（自己总结，测试过可行） ajax返回如果含有中文汉字，则使用：（如下例：） @RequestMapping(value="/xxx.do")       public @ResponseBody void getPunishReasonB
  • Linux系统中查看日志的常用命令 dcj3sjt126com OS
    因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 cat tail -f 日 志 文 件 说 明 /var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关的日志信息 /var/log/maillog 与邮件相关的日志信
  • [应用结构]应用 dcj3sjt126com PHPyii2
    应用主体 应用主体是管理 Yii 应用系统整体结构和生命周期的对象。 每个Yii应用系统只能包含一个应用主体，应用主体在 入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。 补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
  • assertThat用法 eksliang JUnitassertThat
    junit4.0  assertThat用法 一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 2、assertThat( testedNumber, anyOf( g
  • android点滴2 gundumw100 应用服务器android网络应用OSHTC
    如何让Drawable绕着中心旋转？ Animation a = new RotateAnimation(0.0f, 360.0f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f); a.setRepeatCount(-1); a.setDuration(1000); 如何控制Andro
  • 超简洁的CSS下拉菜单 ini htmlWeb工作html5css
    效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>简洁的HTML+CSS下拉菜单-HoverTree</title>
  • kafka consumer防止数据丢失 kane_xie kafkaoffset commit
    kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。   尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。   考虑这样一个case，partiton_num=2
  • @Repository、@Service、@Controller 和 @Component mhtbbx DAOspringbeanprototype
    @Repository、@Service、@Controller 和 @Component 将类标识为Bean Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
  • java 多线程高并发读写控制 误区 qifeifei java thread
    先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ public class testTh7 { private String data; public String read(){ System.out.println(Thread.currentThread().getName() + "read data "
  • mongodb replica set(副本集)设置步骤 tcrct javamongodb
    网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下： 首先先去下载一个mongodb最新版，目前最新版应该是2.6 cd /usr/local/bin wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz tar -zxvf mongodb-linux-x86_64-2.6.0.t
  • rust学习笔记 wudixiaotie 学习笔记
    1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 let x = 1; let mut y = 2; 2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 4.每个语句结尾都要加分