ART虚拟机GC清除SoftReference(软引用)源码解析

最新推荐文章于 2024-08-22 17:30:40 发布
最新推荐文章于 2024-08-22 17:30:40 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lylwo317/article/details/87909598
版权

引言

SoftReference保存的对象实例，除非JVM即将OutOfMemory，否则不会被GC回收。下面我们就从Android 8.0的源码来探索一下具体清空过程和条件，有关GC原理不在讨论范围。

触发因kGcCauseForAlloc导致的GC（内存不够的情况下引起的GC）

在Activity写个循环创建大量的java对象触发kGcCauseForAlloc

对应的java方法

public class MainActivity extends AppCompatActivity {
    List<SoftReference<List<String>>> softReferenceList = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        TextView contentText = (TextView) findViewById(R.id.sample_text);
        contentText.setText("Allocate");
        contentText.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                for (int i = 0; i < 10000; i++) {
                    softReferenceList.add(new SoftReference<List<String>>(new ArrayList<String>(10240)));
                }
            }
        }); 
    }
}

点击“Allocate”按钮触发大量Java对象生成。运行一会后最终会触发ART中的调试断点

断点调试ART GC的调用栈

art::mirror::Object::SetFieldObjectWithoutWriteBarrier<false, true, (art::VerifyObjectFlags)0, true> object-inl.h:771
art::mirror::Object::SetFieldObject<false, true, (art::VerifyObjectFlags)0, true> object-inl.h:781
art::mirror::Object::SetFieldObjectVolatile<false, true, (art::VerifyObjectFlags)0> object-inl.h:792
art::mirror::Reference::ClearReferent<false> reference.h:75
art::gc::ReferenceQueue::ClearWhiteReferences reference_queue.cc:144
art::gc::ReferenceProcessor::ProcessReferences reference_processor.cc:168
art::gc::collector::ConcurrentCopying::ProcessReferences concurrent_copying.cc:2648
art::gc::collector::ConcurrentCopying::MarkingPhase concurrent_copying.cc:888
art::gc::collector::ConcurrentCopying::RunPhases concurrent_copying.cc:179
art::gc::collector::GarbageCollector::Run garbage_collector.cc:96
art::gc::Heap::CollectGarbageInternal heap.cc:2607
art::gc::Heap::AllocateInternalWithGc heap.cc:1658(对应下面源码中的第89行)
art::gc::Heap::AllocObjectWithAllocator<false, true, art::mirror::SetLengthVisitor> heap-inl.h:116
art::mirror::Array::Alloc<false, false> array-inl.h:183
art::AllocArrayFromCodeResolved<false> entrypoint_utils-inl.h:313
artAllocArrayFromCodeResolvedRegionTLAB quick_alloc_entrypoints.cc:128
art_quick_alloc_array_resolved32_region_tlab quick_entrypoints_x86.S:1264
...

分析调用栈

执行GC然后再尝试分配内存

art/runtime/gc/heap.cc

//在AllocObjectWithAllocator调用这个函数之前。已经尝试使用TryToAllocate分配内存，但是失败了。本函数将在GC后再次调用TryToAllocate分配内存
mirror::Object* Heap::AllocateInternalWithGc(Thread* self,
                                             AllocatorType allocator,
                                             bool instrumented,
                                             size_t alloc_size,
                                             size_t* bytes_allocated,
                                             size_t* usable_size,
                                             size_t* bytes_tl_bulk_allocated,
                                             ObjPtr<mirror::Class>* klass) {
  bool was_default_allocator = allocator == GetCurrentAllocator();
  // Make sure there is no pending exception since we may need to throw an OOME.
  self->AssertNoPendingException();
  DCHECK(klass != nullptr);
  StackHandleScope<1> hs(self);
  HandleWrapperObjPtr<mirror::Class> h(hs.NewHandleWrapper(klass));
  // The allocation failed. If the GC is running, block until it completes, and then retry the
  // allocation.
  collector::GcType last_gc = WaitForGcToComplete(kGcCauseForAlloc, self);
  // If we were the default allocator but the allocator changed while we were suspended,
  // abort the allocation.
  if ((was_default_allocator && allocator != GetCurrentAllocator()) ||
      (!instrumented && EntrypointsInstrumented())) {
    return nullptr;
  }
  if (last_gc != collector::kGcTypeNone) {
  	//在此之前有一次GC，我们先试试看能不能Allocate成功，成功的话，我们就不需要GC了。
    // A GC was in progress and we blocked, retry allocation now that memory has been freed.
    mirror::Object* ptr = TryToAllocate<true, false>(self, allocator, alloc_size, bytes_allocated,
                                                     usable_size, bytes_tl_bulk_allocated);
    if (ptr != nullptr) {
      return ptr;
    }
  }

  collector::GcType tried_type = next_gc_type_;
  const bool gc_ran =
      CollectGarbageInternal(tried_type, kGcCauseForAlloc, false) != collector::kGcTypeNone;
  if ((was_default_allocator && allocator != GetCurrentAllocator()) ||
      (!instrumented && EntrypointsInstrumented())) {
    return nullptr;
  }
  if (gc_ran) {//gc已经执行
    mirror::Object* ptr = TryToAllocate<true, false>(self, allocator, alloc_size, bytes_allocated,
                                                     usable_size, bytes_tl_bulk_allocated);
    if (ptr != nullptr) {
      return ptr;
    }
  }

	//循环尝试跟当前tried_type不同的GC，直到获取到足够的空闲内存空间或者循环结束退出
  // Loop through our different Gc types and try to Gc until we get enough free memory.
  for (collector::GcType gc_type : gc_plan_) {
    if (gc_type == tried_type) {
      continue;
    }
    // Attempt to run the collector, if we succeed, re-try the allocation.
    const bool plan_gc_ran =
        CollectGarbageInternal(gc_type, kGcCauseForAlloc, false) != collector::kGcTypeNone;
    if ((was_default_allocator && allocator != GetCurrentAllocator()) ||
        (!instrumented && EntrypointsInstrumented())) {
      return nullptr;
    }
    if (plan_gc_ran) {//gc执行完成
      // Did we free sufficient memory for the allocation to succeed?
      //再次尝试Allocate
      mirror::Object* ptr = TryToAllocate<true, false>(self, allocator, alloc_size, bytes_allocated,
                                                       usable_size, bytes_tl_bulk_allocated);
      if (ptr != nullptr) {
        return ptr;
      }
    }
  }
  // Allocations have failed after GCs;  this is an exceptional state.
  // Try harder, growing the heap if necessary.
  // 尝试增长堆大小，控制开关是TryToAllocate<true, /*const bool kGrow*/true>第二个泛型参数kGrow
  mirror::Object* ptr = TryToAllocate<true, true>(self, allocator, alloc_size, bytes_allocated,
                                                  usable_size, bytes_tl_bulk_allocated);
  if (ptr != nullptr) {
    return ptr;
  }
  //大多数分配在到达这里之前应该已经成功了。运行到这里说明堆真的很满，很碎片化，
  //或者要求分配的大小真的很大。 做一次与以往不同的GC，这次将会回收SoftReferences的空间。
  //VM规范要求在抛出OOME之前收集并清除所有SoftReferences
  VLOG(gc) << "Forcing collection of SoftReferences for " << PrettySize(alloc_size)
           << " allocation";
  // TODO: Run finalization, but this may cause more allocations to occur.
  // We don't need a WaitForGcToComplete here either.
  DCHECK(!gc_plan_.empty());
  //请求GC清除所有SoftReferences，控制开关是/*clear_soft_references*/，如字面意思当它为true时清空所有SoftReferences
  CollectGarbageInternal(gc_plan_.back(), kGcCauseForAlloc, /*clear_soft_references*/true);
  if ((was_default_allocator && allocator != GetCurrentAllocator()) ||
      (!instrumented && EntrypointsInstrumented())) {
    return nullptr;
  }
  ptr = TryToAllocate<true, true>(self, allocator, alloc_size, bytes_allocated, usable_size,
                                  bytes_tl_bulk_allocated);
  if (ptr == nullptr) {
    const uint64_t current_time = NanoTime();
    switch (allocator) {
      case kAllocatorTypeRosAlloc:
        // Fall-through.
      case kAllocatorTypeDlMalloc: {
        if (use_homogeneous_space_compaction_for_oom_ &&
            current_time - last_time_homogeneous_space_compaction_by_oom_ >
            min_interval_homogeneous_space_compaction_by_oom_) {
          last_time_homogeneous_space_compaction_by_oom_ = current_time;
          HomogeneousSpaceCompactResult result = PerformHomogeneousSpaceCompact();
          // Thread suspension could have occurred.
          if ((was_default_allocator && allocator != GetCurrentAllocator()) ||
              (!instrumented && EntrypointsInstrumented())) {
            return nullptr;
          }
          switch (result) {
            case HomogeneousSpaceCompactResult::kSuccess:
              // If the allocation succeeded, we delayed an oom.
              ptr = TryToAllocate<true, true>(self, allocator, alloc_size, bytes_allocated,
                                              usable_size, bytes_tl_bulk_allocated);
              if (ptr != nullptr) {
                count_delayed_oom_++;
              }
              break;
            case HomogeneousSpaceCompactResult::kErrorReject:
              // Reject due to disabled moving GC.
              break;
            case HomogeneousSpaceCompactResult::kErrorVMShuttingDown:
              // Throw OOM by default.
              break;
            default: {
              UNIMPLEMENTED(FATAL) << "homogeneous space compaction result: "
                  << static_cast<size_t>(result);
              UNREACHABLE();
            }
          }
          // Always print that we ran homogeneous space compation since this can cause jank.
          VLOG(heap) << "Ran heap homogeneous space compaction, "
                    << " requested defragmentation "
                    << count_requested_homogeneous_space_compaction_.LoadSequentiallyConsistent()
                    << " performed defragmentation "
                    << count_performed_homogeneous_space_compaction_.LoadSequentiallyConsistent()
                    << " ignored homogeneous space compaction "
                    << count_ignored_homogeneous_space_compaction_.LoadSequentiallyConsistent()
                    << " delayed count = "
                    << count_delayed_oom_.LoadSequentiallyConsistent();
        }
        break;
      }
      case kAllocatorTypeNonMoving: {
        if (kUseReadBarrier) {
          // DisableMovingGc() isn't compatible with CC.
          break;
        }
        // Try to transition the heap if the allocation failure was due to the space being full.
        if (!IsOutOfMemoryOnAllocation(allocator, alloc_size, /*grow*/ false)) {
          // If we aren't out of memory then the OOM was probably from the non moving space being
          // full. Attempt to disable compaction and turn the main space into a non moving space.
          DisableMovingGc();
          // Thread suspension could have occurred.
          if ((was_default_allocator && allocator != GetCurrentAllocator()) ||
              (!instrumented && EntrypointsInstrumented())) {
            return nullptr;
          }
          // If we are still a moving GC then something must have caused the transition to fail.
          if (IsMovingGc(collector_type_)) {
            MutexLock mu(self, *gc_complete_lock_);
            // If we couldn't disable moving GC, just throw OOME and return null.
            LOG(WARNING) << "Couldn't disable moving GC with disable GC count "
                         << disable_moving_gc_count_;
          } else {
            LOG(WARNING) << "Disabled moving GC due to the non moving space being full";
            ptr = TryToAllocate<true, true>(self, allocator, alloc_size, bytes_allocated,
                                            usable_size, bytes_tl_bulk_allocated);
          }
        }
        break;
      }
      default: {
        // Do nothing for others allocators.
      }
    }
  }
  // If the allocation hasn't succeeded by this point, throw an OOM error.
  if (ptr == nullptr) {
  	// 抛出OOM错误
    ThrowOutOfMemoryError(self, alloc_size, allocator);
  }
  return ptr;
}

该函数在执行了各种GC后，仍旧无法Allocate时，会尝试增长heap。然而还是无法Allocate，就会执行清空SoftReference的GC。

GC执行的过程中会调用ProcessReferences函数处理Reference

art/runtime/gc/reference_processor.cc

// Process reference class instances and schedule finalizations.
void ReferenceProcessor::ProcessReferences(bool concurrent,
                                           TimingLogger* timings,
                                           bool clear_soft_references,
                                           collector::GarbageCollector* collector) {
  TimingLogger::ScopedTiming t(concurrent ? __FUNCTION__ : "(Paused)ProcessReferences", timings);
  Thread* self = Thread::Current();
  {
    MutexLock mu(self, *Locks::reference_processor_lock_);
    collector_ = collector;
    if (!kUseReadBarrier) {
      CHECK_EQ(SlowPathEnabled(), concurrent) << "Slow path must be enabled iff concurrent";
    } else {
      // Weak ref access is enabled at Zygote compaction by SemiSpace (concurrent == false).
      CHECK_EQ(!self->GetWeakRefAccessEnabled(), concurrent);
    }
  }
  if (kIsDebugBuild && collector->IsTransactionActive()) {
    // In transaction mode, we shouldn't enqueue any Reference to the queues.
    // See DelayReferenceReferent().
    DCHECK(soft_reference_queue_.IsEmpty());
    DCHECK(weak_reference_queue_.IsEmpty());
    DCHECK(finalizer_reference_queue_.IsEmpty());
    DCHECK(phantom_reference_queue_.IsEmpty());
  }
  // Unless required to clear soft references with white references, preserve some white referents.
  if (!clear_soft_references) {//不清除SoftReference
    TimingLogger::ScopedTiming split(concurrent ? "ForwardSoftReferences" :
        "(Paused)ForwardSoftReferences", timings);
    if (concurrent) {
      StartPreservingReferences(self);
    }
    // TODO: Add smarter logic for preserving soft references. The behavior should be a conditional
    // mark if the SoftReference is supposed to be preserved.
    // 标记soft_reference_queue_中的SoftReference，这样就不会被清除了
    soft_reference_queue_.ForwardSoftReferences(collector);
    collector->ProcessMarkStack();
    if (concurrent) {
      StopPreservingReferences(self);
    }
  }
  // Clear all remaining soft and weak references with white referents.
  soft_reference_queue_.ClearWhiteReferences(&cleared_references_, collector);
  weak_reference_queue_.ClearWhiteReferences(&cleared_references_, collector);
  {
    TimingLogger::ScopedTiming t2(concurrent ? "EnqueueFinalizerReferences" :
        "(Paused)EnqueueFinalizerReferences", timings);
    if (concurrent) {
      StartPreservingReferences(self);
    }
    // Preserve all white objects with finalize methods and schedule them for finalization.
    finalizer_reference_queue_.EnqueueFinalizerReferences(&cleared_references_, collector);
    collector->ProcessMarkStack();
    if (concurrent) {
      StopPreservingReferences(self);
    }
  }
  // Clear all finalizer referent reachable soft and weak references with white referents.
  soft_reference_queue_.ClearWhiteReferences(&cleared_references_, collector);
  weak_reference_queue_.ClearWhiteReferences(&cleared_references_, collector);
  // Clear all phantom references with white referents.
  phantom_reference_queue_.ClearWhiteReferences(&cleared_references_, collector);
  // At this point all reference queues other than the cleared references should be empty.
  DCHECK(soft_reference_queue_.IsEmpty());
  DCHECK(weak_reference_queue_.IsEmpty());
  DCHECK(finalizer_reference_queue_.IsEmpty());
  DCHECK(phantom_reference_queue_.IsEmpty());
  {
    MutexLock mu(self, *Locks::reference_processor_lock_);
    // Need to always do this since the next GC may be concurrent. Doing this for only concurrent
    // could result in a stale is_marked_callback_ being called before the reference processing
    // starts since there is a small window of time where slow_path_enabled_ is enabled but the
    // callback isn't yet set.
    collector_ = nullptr;
    if (!kUseReadBarrier && concurrent) {
      // Done processing, disable the slow path and broadcast to the waiters.
      DisableSlowPath(self);
    }
  }
}

以上函数会在标记阶段调用。函数根据clear_soft_references函数参数决定是否要标记所有已经插入到ReferenceQueue队列中的SoftReference，true则不标记，flase则标记。被标记的SoftReference将会被保留（不被GC清除）。由此可见clear_soft_references就如字面意思所表示的，是控制是否清空SoftReference的开关

art/runtime/gc/reference_queue.cc

void ReferenceQueue::ClearWhiteReferences(ReferenceQueue* cleared_references,
                                          collector::GarbageCollector* collector) {
  while (!IsEmpty()) {
    ObjPtr<mirror::Reference> ref = DequeuePendingReference();
    mirror::HeapReference<mirror::Object>* referent_addr = ref->GetReferentReferenceAddr();
    // do_atomic_update is false because this happens during the reference processing phase where
    // Reference.clear() would block.
    if (!collector->IsNullOrMarkedHeapReference(referent_addr, /*do_atomic_update*/false)) {
      // Referent is white, clear it.
      if (Runtime::Current()->IsActiveTransaction()) {
        ref->ClearReferent<true>();
      } else {
        ref->ClearReferent<false>();
      }
      // 加入到cleared_references
      cleared_references->EnqueueReference(ref);
    }
    // Delay disabling the read barrier until here so that the ClearReferent call above in
    // transaction mode will trigger the read barrier.
    DisableReadBarrierForReference(ref);
  }
}

art/runtime/mirror/reference.h

  template<bool kTransactionActive>
  void ClearReferent() REQUIRES_SHARED(Locks::mutator_lock_) {
  	//将SoftReference.java中的volatile成员变量reference置为null
    SetFieldObjectVolatile<kTransactionActive>(ReferentOffset(), nullptr);
  }

art/runtime/gc/reference_queue.cc

void ReferenceQueue::EnqueueReference(ObjPtr<mirror::Reference> ref) {
  DCHECK(ref != nullptr);
  CHECK(ref->IsUnprocessed());
  if (IsEmpty()) {
    // 1 element cyclic queue, ie: Reference ref = ..; ref.pendingNext = ref;
    list_ = ref.Ptr();
  } else {
    // The list is owned by the GC, everything that has been inserted must already be at least
    // gray.
    ObjPtr<mirror::Reference> head = list_->GetPendingNext<kWithoutReadBarrier>();
    DCHECK(head != nullptr);
    ref->SetPendingNext(head);
  }
  // Add the reference in the middle to preserve the cycle.
  list_->SetPendingNext(ref);
}

总结

从上面的代码分析中，验证了这个结论——SoftReference的确是只有在即将抛出OutOfMemoryError的情况下，才会被GC回收。

当我们希望被缓存的对象最好始终常驻内存，但是如果JVM内存吃紧，为了不发生OutOfMemoryError导致系统崩溃，允许JVM回收Cache的内存，然后这个缓存对象在回收后不会立即需要加载到内存中。这个时候就是使用SoftReference的最佳场景。

心中要有一片海
关注
专栏目录
深入理解ART虚拟机—虚拟机的启动
threepigs的专栏
10-11 1万+
看art虚拟机也有一段时间了，是时候写点什么出来了。早先看art的时候，发现不是太能理解，所以就恶补了一下dalvik虚拟机，所以有了之前的dalvik系列，等再次回头看art的时候，确实轻松了不少。 art从Android L开始正式替换dalvik，成为Android的默认虚拟机，L的art源码和之前KK的差别比较大，网上很多分析ART的文章都是基于KK的art源码。L开始art才走向成熟，
android的GC内存泄露问题
09-01
在Android中，每个应用都有独立的Dalvik或ART虚拟机实例，因此一个应用的内存泄露只会导致该应用进程被杀死，不会波及其他应用。 2. 引起内存泄露的情况： a) 资源对象未关闭：如Cursor、File等资源性对象通常包含...
ART虚拟机 | Cleaner机制源码分析
1.01的365次方的专栏
05-17 691
目录 思考问题 1.Android为什么要讲Finalize机制替换成Cleaner机制？ 2.Cleaner机制回收Native堆内存的原理是什么？ 3.Cleaner机制源码是如何实现的？ 一、版本 基于Andrroid 11(R) 二、类图 三、流程 3.1 KOOM初始化流程 + 内存监控流程 补充1 四、问题 五、总结 优点 1.使用了自己的内存检测策略，将内存泄漏的检测延后 1.1配置内存阈值 1.2配...
ART运行时垃圾收集（GC）过程分析
热门推荐
老罗的Android之旅
01-26 6万+
ART运行时与Dalvik虚拟机一样，都使用了Mark-Sweep算法进行垃圾回收，因此它们的垃圾回收流程在总体上是一致的。但是ART运行时对堆的划分更加细致，因而在此基础上实现了更多样的回收策略。不同的策略有不同的回收力度，力度越大的回收策略，每次回收的内存就越多，并且它们都有各自的使用情景。这样就可以使得每次执行GC时，可以最大限度地减少应用程序停顿。本文就详细分析ART运行时的垃圾收集过程。
ART堆内存系列：GC抑制从入门到精通
最新发布
chuyouyinghe的专栏
08-22 61
本文从线下发现的GC导致主线程卡顿的问题入手引出抑制GC解决问题的思路，并对ART虚拟机执行GC的类型和触发时机做了详细的分析。从第一性原理出发，寻找可能的两种解决思路，分别是增大并发GC阈值和阻塞ConcurrentGCTask执行，并在这两种思路下探讨可落地的方案，最终成功找到阻塞ConcurrentGCTask执行的方案，并上线通过AB实验验证收益。
Android Art Gc - 概述
01-08 1981
基于Android Q源码： 1.GC 回收算法 GC目前只有四种基本方法： （1）Mark-Sweep Collection 标记清除算法 （2）Copying Collection 复制算法 （3）Mark-Compact Collection 标记-压缩算法 （3）Reference Counting 引用计数算法--未被art采用 目前art默认使用的GC方案： concurrent...
android art GC笔记
weixin_30701521的博客
02-08 151
GC理解的重点之一是SuspendAll机制，即停止所有线程。 请求GC的线程会在每一个java线程的状态位中置上kRequestSuspend位，接着此线程进入等待状态，等待所有线程响应并清除此kRequestSuspend位。 因为java dex字节码中会嵌入checkpoint点，java线程跑到checkpoint点的时候，即检查是否有kRequestSuspend位；如果有，...
Dalvik与ART的GC调试
weizaishouex2010的专栏
05-26 919
转载自： http://gityuan.com/2015/10/03/Android-GC/ 一、Dalvik 1.1 GC含义 Dalvik虚拟机，每一次GC打印内容格式： D/dalvikvm: , , , 中文版： D/dalvikvm: , , , 含义解析 GC Reason(GC触发原因) GC_CONC
安卓Android源码——防止内存溢出浅析.zip
10-14
Android系统使用Dalvik或ART虚拟机来执行应用，它们都是基于垃圾收集（Garbage Collection, GC）的机制。当对象不再被引用时，GC会自动回收这些对象占用的内存。然而，如果程序中存在内存泄漏，即对象虽然不再使用，...
Android应用源码之防止内存溢出浅析.zip
10-14
应使用弱引用（WeakReference）或软引用（SoftReference）来包裹这些对象。 2. 使用Android提供的工具：如LeakCanary，它可以帮助检测应用中的内存泄漏，并提供详细的泄漏堆栈追踪。 3. 管理Bitmap：Bitmap对象占...
Android 5.0 ART GC 对比 Android 4.x Dalvik GC
@毛宏斌
01-03 1万+
为了研究Android虚拟机中的内存管理机制，前期进行了初步调研，下面列出Android 5.0 ART 中GC的更新概要以供参考，资料来源于网络以及对源码的初步阅读。
从源代码看：为什么可以软引用，弱引用，虚引用
dpsp
12-26 408
通过分析java源代码，分析java弱引用，软引用，虚引用间的区别
了解一下，Android 10中的ART虚拟机(8)
Innost的专栏
07-03 7083
缘起继续从读书笔记的角度来系统的学习《Advanced Design and Implementation of Virtual Machines》。这本书是英文编写，全部、认真、深入的...
art和java的gc_Full GC 和 Minor GC，傻傻分不清楚
weixin_35798040的博客
02-27 123
这篇文章主要来介绍下 JVM 中的各种 GC，让大家来搞清楚这几个概念。大家可能见到过很多的 GC 名词，比如：Minor GC、Young GC、Full GC、Old GC、Major GC、Mixed GC。这么多概念，想想都头疼，到底各种乱七八糟的 GC 指的是什么?下面先引用 R 大在知乎上的回答：针对 HotSpot VM 的实现，它里面的 GC 其实准确分类有两种:Partial G...
软引用、弱引用、虚引用 总结
zhxing
01-15 295
   在看‘深入JAVA虚拟机’垃圾收集这一章的时候了解有关对象的引用级别，在网上找了些资料总结备忘。（该文章大多内容为多个网站的内容合并）   1、概述    在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这 就像在日常生活中，从商店购买了某样物品后，如果有用，就一直保留它，否则就把它扔到垃圾箱，由清...
Java ~ Reference ~ SoftReference【源码】
说淑人的所思所想
11-13 553
SoftReference（软引用）类是Reference（引用）类的四大子类之一，只被SoftReference（软引用）类对象持有的对象（即被作为所指对象）被称为软可达（softly reachable）对象。 SoftReference（软引用）类适合用于做缓存。 对软可达对象的所有软引用保证在虚拟机抛出OOM之前已被清除。
Android ART 虚拟机简析
私房菜
05-20 1097
用来执行显示GC，例如 system.gc() 接口；，用来执行并行GC，只能被 ART 运行时内部的GC 守护线程调用；，ART运行时内部调用的GC 接口，可以执行各种类型的GC；ART runtime 将空间划分：Image Space、Malloc Space、Zygote Space、Bump Pointer Space、Region Space、Large Object Space。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值