ZPage* const page = alloc_page(ZPageTypeLarge, page_size, flags);
if (page != NULL) {
// Allocate the object
addr = page->alloc_object(size);
}
return addr;
}
-
分配大对象时,触发分配 large page;
-
对齐大对象 size 到 2MB 的倍数后分配 large page。
zObjectAllocator.cpp
uintptr_t ZObjectAllocator::alloc_object(size_t size, ZAllocationFlags flags) {
if (size <= ZObjectSizeLimitSmall) {
// Small
return alloc_small_object(size, flags);
} else if (size <= ZObjectSizeLimitMedium) {
// Medium
return alloc_medium_object(size, flags);
} else {
// Large
return alloc_large_object(size, flags);
}
}
-
当对象 size 大于 medium 页对象 size 限制时,触发大对象分配;
-
因此,large 页的实际 size 很可能小于 medium 页 size。
Page 的分配
Page 分配的入口在 ZHeap 的 alloc_page 方法:
zHeap.cpp
ZPage* ZObjectAllocator::alloc_page(uint8_t type, size_t size, ZAllocationFlags flags) {
// 调用了page分配器的alloc_page函数
ZPage* const page = ZHeap::heap()->alloc_page(type, size, flags);
if (page != NULL) {
// 增加使用内存数
Atomic::add(_used.addr(), size);
}
return page;
}
zPageAllocator.cpp
ZPage* ZPageAllocator::alloc_page(uint8_t type, size_t size, ZAllocationFlags flags) {
EventZPageAllocation event;
retry:
ZPageAllocation allocation(type, size, flags);
// 从page cache分配page
// 如果分配成功,调用alloc_page_finalize完成分配
// 分配过程中,如果是阻塞模式,有可能在安全点被阻塞
if (!alloc_page_or_stall(&allocation)) {
// Out of memory
return NULL;
}
// 如果从page cache分配失败,则从物理内存申请页
// 提交page
ZPage* const page = alloc_page_finalize(&allocation);
if (page == NULL) {
// 如果commit或者map失败,则goto到retry,重新分配
alloc_page_failed(&allocation);
goto retry;
}
// …
// …
// …
return page;
}
bool ZPageAllocator::alloc_page_or_stall(ZPageAllocation* allocation) {
{
// 分配page需要上锁,因为只有一个堆
ZLocker locker(&_lock);
// 分配成功,返回true
if (alloc_page_common(allocation)) {
return true;
}
// 如果是非阻塞模式,返回false
if (allocation->flags().non_blocking()) {
return false;
}
// 分配请求入队,等待GC完成
_stalled.insert_last(allocation);
}
return alloc_page_stall(allocation);
}
// 阻塞分配,等待GC
bool ZPageAllocator::alloc_page_stall(ZPageAllocation* allocation) {
ZStatTimer timer(ZCriticalPhaseAllocationStall);
EventZAllocationStall event;
ZPageAllocationStall result;
// 检查虚拟机是否已经完成初始化
check_out_of_memory_during_initialization();
do {
// 启动异步GC
ZCollectedHeap::heap()->collect(GCCause::_z_allocation_stall);
// 挂起,等待GC结果
result = allocation->wait();
} while (result == ZPageAllocationStallStartGC);
// …
// …
// …
return (result == ZPageAllocationStallSuccess);
}
- 阻塞分配与非阻塞分配,由系统参数 ZStallOnOutOfMemory 控制,默认阻塞分配。阻塞分配时,如果分配失败,则触发 GC,等待 GC 结束后再次分配,直到分配成功。
对象分配
自从 JDK10 中的引入了 JEP 304: Garbage Collector Interface 后,OpenJDK 定义了一整套关于 GC 的虚方法,供具体的 GC 算法实现。极大了简化了开发难度和代码的可维护性。
JEP 304 定义了 CollectedHeap 类,每个 GC 都需要实现。CollectedHeap 类负责驱动 HotSpot 的 GC,以及和其他模块的交互。GC 应当实现如下功能:
-
CollectedHeap 的子类;
-
BarrierSet 集合类的实现,提供在运行时各种屏障功能;
-
CollectorPolicy 类的实现;
-
GCInterpreterSupport 的实现,提供 GC 在解释执行时各种屏障功能(使用汇编指令);
-
GCC1Support 的实现,提供 GC 在 C1 编译代码中各种屏障功能;
-
GCC2Support 的实现,提供 GC 在 C2 编译代码中各种屏障功能;
-
最终 GC 指定参数的初始化;
-
一个 MemoryService,提供内存池、内存管理等。
通常地,对象分配的入口在 InstanceKlass::allocate_instance,该方法调用 heap->obj_allocate()进行分配。
instanceOop InstanceKlass::allocate_instance(TRAPS) {
bool has_finalizer_flag = has_finalizer(); // Query before possible GC
int size = size_helper(); // Query before forming handle.
instanceOop i;
i = (instanceOop)Universe::heap()->obj_allocate(this, size, CHECK_NULL);
if (has_finalizer_flag && !RegisterFinalizersAtInit) {
// 对于实现了finalize方法的类的实例的特殊处理
i = register_finalizer(i, CHECK_NULL);
}
return i;
}
CollectedHeap 对象分配流程图
对象分配一般遵循如下流程:
源码分析
ZCollectedHeap
ZCollectedHeap 重载了 CollectedHeap 的方法,其中包含了对象分配的相关方法。而核心逻辑在放在 ZHeap 中。ZCollectedHeap 中主要的成员方法如下:
class ZCollectedHeap : public CollectedHeap {
friend class VMStructs;
private:
// 软引用清理策略
SoftRefPolicy _soft_ref_policy;
// 内存屏障,解释执行/C1/C2执行时对象访问的屏障
ZBarrierSet _barrier_set;
// 初始化逻辑
ZInitialize _initialize;
// 堆管理的核心逻辑,包括对象分配、转移、标记
ZHeap _heap;
// 垃圾回收线程,触发
ZDirector* _director;
// 垃圾回收线程,执行
ZDriver* _driver;
// 垃圾回收线程,统计
ZStat* _stat;
// 工作线程
ZRuntimeWorkers _runtime_workers;
}
ZHeap
ZHeap 是 ZGC 内存管理的核心类。主要变量如下:
class ZHeap {
friend class VMStructs;
private:
static ZHeap* _heap;
// 工作线程
ZWorkers _workers;
// 对象分配器
ZObjectAllocator _object_allocator;
// 页面分配器
ZPageAllocator _page_allocator;
// 页表
ZPageTable _page_table;
// 转发表,用于对象迁移后的指针映射
ZForwardingTable _forwarding_table;
// 标记管理
ZMark _mark;
// 引用处理器
ZReferenceProcessor _reference_processor;
// 弱引用处理器
ZWeakRootsProcessor _weak_roots_processor;
// 转移管理器,用于对象迁移(类比G1的疏散)
ZRelocate _relocate;
// 转移集合
ZRelocationSet _relocation_set;
// 从元空间卸载类
ZUnload _unload;
ZServiceability _serviceability;
}
对象分配器
对象分配的主要逻辑在 ZObjectAllocator。
对象分配器主要变量
ZObjectAllocator 的主要变量如下:
class ZObjectAllocator {
private:
const bool _use_per_cpu_shared_small_pages;
// 分CPU记录使用内存size
ZPerCPU<size_t> _used;
// 分CPU记录undo内存size
ZPerCPU<size_t> _undone;
// 缓存行对齐的模板类
ZContended<ZPage*> _shared_medium_page;
// 按CPU从缓存分配对象
ZPerCPU<ZPage*> _shared_small_page;
}
分配方法
对象分配的核心方法是 alloc_object
uintptr_t ZObjectAllocator::alloc_object(size_t size, ZAllocationFlags flags) {
if (size <= ZObjectSizeLimitSmall) {
// Small
return alloc_small_object(size, flags);
} else if (size <= ZObjectSizeLimitMedium) {
// Medium
return alloc_medium_object(size, flags);
} else {
// Large
return alloc_large_object(size, flags);
}
}
-
按对象的 size,决定调用 small page 分配、medium page 分配还是 large page 分配。
-
分配入参除了 size 外,还有个 ZAllocationFlags。ZAllocationFlags 是个 8bit 的配置参数。
large page 分配方法如下:
uintptr_t ZObjectAllocator::alloc_large_object(size_t size, ZAllocationFlags flags) {
uintptr_t addr = 0;
// 对齐2MB
const size_t page_size = align_up(size, ZGranuleSize);
// 分配页面
ZPage* const page = alloc_page(ZPageTypeLarge, page_size, flags);
if (page != NULL) {
// 在页面中分配对象
addr = page->alloc_object(size);
}
return addr;
}
-
small page 分配和 medium page 分配都会调用到 alloc_object_in_shared_page 方法;
-
小对象和中对象的分配略有不同,小对象是根据所在 CPU 从共享页面中分配对象。而中对象则是全部线程共享一个 medium page。
// shared_page:页面地址
// page_type:page类型,small还是medium
// page_size: page size
// size: 对象size
// flags: 分配标识
uintptr_t ZObjectAllocator::alloc_object_in_shared_page(ZPage** shared_page,
uint8_t page_type,
size_t page_size,
size_t size,
ZAllocationFlags flags) {
uintptr_t addr = 0;
// 获取一个page
ZPage* page = Atomic::load_acquire(shared_page);
if (page != NULL) {
// 调用page的分配对象方法
addr = page->alloc_object_atomic(size);
}
if (addr == 0) {
// 如果刚才没有获取page成功,则分配一个new page
ZPage* const new_page = alloc_page(page_type, page_size, flags);
if (new_page != NULL) {
// 先分配对象,然后加载page到shared_page缓存
addr = new_page->alloc_object(size);
retry:
// 加载page到shared_page缓存
ZPage* const prev_page = Atomic::cmpxchg(shared_page, page, new_page);
if (prev_page != page) {
if (prev_page == NULL) {
// 如果prev_page已经淘汰,则goto到retry一直重试
page = prev_page;
goto retry;
}
// 其他线程加载了页面,则使用prev_page分配
const uintptr_t prev_addr = prev_page->alloc_object_atomic(size);
if (prev_addr == 0) {
// 如果分配失败,则goto到retry一直重试
page = prev_page;
goto retry;
}
addr = prev_addr;
undo_alloc_page(new_page);
}
}
}
return addr;
}
Page 内的对象分配
page 内的对象分配主要是两个方法 alloc_object_atomic 和 alloc_object,其中 alloc_object 没有锁竞争,主要用于新 page 的第一次对象分配。
先看 alloc_object_atomic
inline uintptr_t ZPage::alloc_object_atomic(size_t size) {
assert(is_allocating(), “Invalid state”);
// 对象对齐,默认8字节对齐
const size_t aligned_size = align_up(size, object_alignment());
uintptr_t addr = top();
for (;😉 {
const uintptr_t new_top = addr + aligned_size;
if (new_top > end()) {
// page没有申昱空间,则返回0
return 0;
}
// cas操作更新prev_top指针
const uintptr_t prev_top = Atomic::cmpxchg(&_top, addr, new_top);
if (prev_top == addr) {
// 调用ZAddress::good获取colored pointer
return ZAddress::good(addr);
}
// 无限重试
addr = prev_top;
}
}
再看看 alloc_object
inline uintptr_t ZPage::alloc_object(size_t size) {
assert(is_allocating(), “Invalid state”);
// 对象空间对齐,默认8字节
const size_t aligned_size = align_up(size, object_alignment());
const uintptr_t addr = top();
const uintptr_t new_top = addr + aligned_size;
if (new_top > end()) {
// 剩余空间不足,返回0
return 0;
}
_top = new_top;
// 调用ZAddress::good获取colored pointer
return ZAddress::good(addr);
}
Colored pointer 的计算
可以看到上述两个方法在分配结束都调用了 ZAddress::good 返回 colored pointer。看看 ZAddress::good 的实现。
inline uintptr_t ZAddress::offset(uintptr_t value) {
return value & ZAddressOffsetMask;
}
inline uintptr_t ZAddress::good(uintptr_t value) {
return offset(value) | ZAddressGoodMask;
}
void ZAddress::set_good_mask(uintptr_t mask) {
ZAddressGoodMask = mask;
ZAddressBadMask = ZAddressGoodMask ^ ZAddressMetadataMask;
ZAddressWeakBadMask = (ZAddressGoodMask | ZAddressMetadataRemapped | ZAddressMetadataFinalizable) ^ ZAddressMetadataMask;
}
-
good 方法其实挺简单,先取 4 位染色值,然后或操作实际地址,获取 colored pointer。
-
colored pointer 将在 load barrier 中使用,后文将详细介绍 load barrier 机制。
读屏障
对于并发 GC 来说,最复杂的事情在于 GC worker 在标记-整理,而 Java 线程(Mutator)同时还在不断的创建新对象、修改字段,不停的更新对象引用关系。因此并发 GC 一般采用两种策略 Incremental Update(增量更新、CMS) 和 SATB(snapshot at beginning、G1) ,两种策略网上介绍文章很多,此处不再赘述。
SATB 重点关注引用关系的删除,可以参考我之前的博客 JVM G1 源码分析(四)- Dirty Card Queue Set(https://blog.csdn.net/a860MHz/article/details/97631300),而 Incremental Update 重点关注引用关系的增加。
而 ZGC 并没有采取类似方式,而是借助读屏障、colored pointer 来实现并发标记-整理。
原理
什么是 Load Barrier
-
一小段在最佳位置由 JIT 注入的代码
-
从堆中加载一个对象引用时
-
检查这个引用是否是 bad color
-
如果是,则自愈
Load Barrier 的触发
从堆中加载对象引用时触发 load barrier。
// 从堆中加载一个对象引用,需要load barrier
String n = person.name;
// 不需要load barrier,不是从堆中加载
String p = n;
// 不需要load barrier,不是从堆中加载
n.isEmpty();
// 不需要load barrier,不是引用类型
int age = person.age;
当引用类型 n 被赋值修改后,在下一次使用 n 前,会测试 n 的染色指针是否为 good。此时测试为 bad color 可知 n 的引用地址进行过修改,需要自愈。
触发 load barrier 的伪代码如下:
// 从堆中加载一个对象引用,需要load barrier
String n = person.name;
if (n & bad_bit_mask) {
slow_path(register_for(n), address_of)
}
对应的汇编代码:
// String n = person.name;
mov 0x10(%rax), %rbx
// 是否bad color
test %rbx, (0x16)%r15
// 如是,进入slow path
jnz slow_path
源码分析
掩码
zGlobals.hpp
//
// Good/Bad mask states
// --------------------
//
// GoodMask BadMask WeakGoodMask WeakBadMask
// --------------------------------------------------------------
// Marked0 001 110 101 010
// Marked1 010 101 110 001
// Remapped 100 011 100 011
//
// Good/bad masks
extern uintptr_t ZAddressGoodMask;
extern uintptr_t ZAddressBadMask;
extern uintptr_t ZAddressWeakBadMask;
zAddress.inline.hpp
inline bool ZAddress::is_null(uintptr_t value) {
return value == 0;
}
inline bool ZAddress::is_bad(uintptr_t value) {
return value & ZAddressBadMask;
}
inline bool ZAddress::is_good(uintptr_t value) {
return !is_bad(value) && !is_null(value);
}
从以上两段代码可以很清晰看出,colored pointer 的状态是 Good/WeakGood/Bad/WeakBad 由 GoodMask 及 BadMask 来测定。
同时,GoodMask、BadMask 由 GC 所处的阶段决定。
void ZAddress::set_good_mask(uintptr_t mask) {
ZAddressGoodMask = mask;
ZAddressBadMask = ZAddressGoodMask ^ ZAddressMetadataMask;
ZAddressWeakBadMask = (ZAddressGoodMask | ZAddressMetadataRemapped | ZAddressMetadataFinalizable) ^ ZAddressMetadataMask;
}
void ZAddress::initialize() {
ZAddressOffsetBits = ZPlatformAddressOffsetBits();
ZAddressOffsetMask = (((uintptr_t)1 << ZAddressOffsetBits) - 1) << ZAddressOffsetShift;
ZAddressOffsetMax = (uintptr_t)1 << ZAddressOffsetBits;
ZAddressMetadataShift = ZPlatformAddressMetadataShift();
ZAddressMetadataMask = (((uintptr_t)1 << ZAddressMetadataBits) - 1) << ZAddressMetadataShift;
ZAddressMetadataMarked0 = (uintptr_t)1 << (ZAddressMetadataShift + 0);
ZAddressMetadataMarked1 = (uintptr_t)1 << (ZAddressMetadataShift + 1);
ZAddressMetadataRemapped = (uintptr_t)1 << (ZAddressMetadataShift + 2);
ZAddressMetadataFinalizable = (uintptr_t)1 << (ZAddressMetadataShift + 3);
ZAddressMetadataMarked = ZAddressMetadataMarked0;
set_good_mask(ZAddressMetadataRemapped);
}
void ZAddress::flip_to_marked() {
ZAddressMetadataMarked ^= (ZAddressMetadataMarked0 | ZAddressMetadataMarked1);
set_good_mask(ZAddressMetadataMarked);
}
void ZAddress::flip_to_remapped() {
set_good_mask(ZAddressMetadataRemapped);
}
比如,ZGC 初始化后,地址视图为 Remapped,GoodMask 是 100,BadMask 是 011。进入标记阶段后,地址视图切换为 M0,GoodMask 和 BadMask 变更为 001 和 110。
屏障的进入条件
accessDecorators.cpp
// === Access Location ===
// 对堆的访问
const DecoratorSet IN_HEAP = UCONST64(1) << 18;
// 对堆外的访问
const DecoratorSet IN_NATIVE = UCONST64(1) << 19;
const DecoratorSet IN_DECORATOR_MASK = IN_HEAP | IN_NATIVE;
zBarrierSet.cpp
bool ZBarrierSet::barrier_needed(DecoratorSet decorators, BasicType type) {
assert((decorators & AS_RAW) == 0, “Unexpected decorator”);
//assert((decorators & ON_UNKNOWN_OOP_REF) == 0, “Unexpected decorator”);
// 是否引用类型
if (is_reference_type(type)) {
// 是否从堆中或者堆外加载一个对象引用
assert((decorators & (IN_HEAP | IN_NATIVE)) != 0, “Where is reference?”);
// Barrier needed even when IN_NATIVE, to allow concurrent scanning.
return true;
}
// Barrier not needed
return false;
}
屏障
load barrier 的入口代码在 zBarrier.inline.hpp
// 模板函数
template <ZBarrierFastPath fast_path, ZBarrierSlowPath slow_path>
inline oop ZBarrier::barrier(volatile oop* p, oop o) {
const uintptr_t addr = ZOop::to_address(o);
// 如果是good指针,只需做一次类型转换
if (fast_path(addr)) {
return ZOop::from_address(addr);
}
// 否则,进入slow path
const uintptr_t good_addr = slow_path(addr);
// 指针自愈
if (p != NULL) {
self_heal<fast_path>(p, addr, good_addr);
}
// 类型转换
return ZOop::from_address(good_addr);
}
-
barrier 接收两个模板函数指针,根据输入函数的执行结果决定走 fast path 还是 slow path;
-
fast path 仅需一次类型转换;
-
slow path 执行后,还需要进行指针自愈,最后返回前做类型转换。
fast path
fast path 根据执行场景和 colored pointer 不同有不少选择,使用比较多的如下:zBarrier.inline.hpp
// 又调回到ZAddress的inline函数了,都是一堆用colored pointer & 掩码的操作
inline bool ZBarrier::is_good_or_null_fast_path(uintptr_t addr) {
return ZAddress::is_good_or_null(addr);
}
inline bool ZBarrier::is_weak_good_or_null_fast_path(uintptr_t addr) {
return ZAddress::is_weak_good_or_null(addr);
}
inline bool ZBarrier::is_marked_or_null_fast_path(uintptr_t addr) {
return ZAddress::is_marked_or_null(addr);
}
slow path
同样的 slow path 根据场景不同,也有好几个选择,但是使用较多的就是 load_barrier_on_oop_slow_path zBarrier.cpp
uintptr_t ZBarrier::load_barrier_on_oop_slow_path(uintptr_t addr) {
// 迁移还是标记
return relocate_or_mark(addr);
}
// 迁移
uintptr_t ZBarrier::relocate(uintptr_t addr) {
assert(!ZAddress::is_good(addr), “Should not be good”);
assert(!ZAddress::is_weak_good(addr), “Should not be weak good”);
// 调用heap的relocate_object
return ZHeap::heap()->relocate_object(addr);
}
迁移对象
zHeap.inline.cpp zRelocate.cpp
// 迁移对象
inline uintptr_t ZHeap::relocate_object(uintptr_t addr) {
assert(ZGlobalPhase == ZPhaseRelocate, “Relocate not allowed”);
// 从forwarding table拿到地址映射关系
// forwarding table会在后文介绍GC的执行过程时详细介绍。先简单理解成一个旧地址到新地址的映射好了。
ZForwarding* const forwarding = _forwarding_table.get(addr);
if (forwarding == NULL) {
// 不在forwarding table内,那就是个good address
return ZAddress::good(addr);
}
// 迁移对象
return _relocate.relocate_object(forwarding, ZAddress::good(addr));
}
// 实际的迁移方法
uintptr_t ZRelocate::relocate_object(ZForwarding* forwarding, uintptr_t from_addr) const {
ZForwardingCursor cursor;
// 在forwarding table找到新地址
// 如果新地址非0,则表示对象已经疏散到新page了,直接返回新地址
// 如果新地址为0,则先迁移对象
uintptr_t to_addr = forwarding_find(forwarding, from_addr, &cursor);
if (to_addr != 0) {
// Already relocated
return to_addr;
}
// 迁移对象
if (forwarding->retain_page()) {
to_addr = relocate_object_inner(forwarding, from_addr, &cursor);
forwarding->release_page();
if (to_addr != 0) {
// 迁移成功
return to_addr;
}
// 如果迁移失败,等待GC 工作线程完成迁移整个page
forwarding->wait_page_released();
}
return forward_object(forwarding, from_addr);
}
标记
zBarrier.cpp zHeap.inline.cpp
template <bool follow, bool finalizable, bool publish>
uintptr_t ZBarrier::mark(uintptr_t addr) {
uintptr_t good_addr;
if (ZAddress::is_marked(addr)) {
// 如果已经标记过,或 Good掩码
good_addr = ZAddress::good(addr);
} else if (ZAddress::is_remapped(addr)) {
// 如果remapped,表示GC开始前创建的对象,或 Good掩码
// 需要标记
good_addr = ZAddress::good(addr);
} else {
// 需要remap和标记
good_addr = remap(addr);
}
// 标记对象
if (should_mark_through(addr)) {
ZHeap::heap()->mark_object<follow, finalizable, publish>(good_addr);
}
if (finalizable) {
// 如果是可回收对象,则或Finalizable和Good掩码
return ZAddress::finalizable_good(good_addr);
}
return good_addr;
}
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)
最后
对于程序员来说,要学习的知识内容、技术有太多太多,要想不被环境淘汰就只有不断提升自己,从来都是我们去适应环境,而不是环境来适应我们!
最后,我再重复一次,如果你想成为一个优秀的 Android 开发人员,请集中精力,对基础和重要的事情做深度研究。
对于很多初中级Android工程师而言,想要提升技能,往往是自己摸索成长,不成体系的学习效果低效漫长且无助。整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路,本文的重点是你有没有收获与成长,其余的都不重要,希望读者们能谨记这一点。
为了大家能够顺利进阶中高级、架构师,我特地为大家准备了一套高手学习的源码和框架视频等精品Android架构师教程,保证你学了以后保证薪资上升一个台阶。
以下是今天给大家分享的一些独家干货:
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
和标记
good_addr = remap(addr);
}
// 标记对象
if (should_mark_through(addr)) {
ZHeap::heap()->mark_object<follow, finalizable, publish>(good_addr);
}
if (finalizable) {
// 如果是可回收对象,则或Finalizable和Good掩码
return ZAddress::finalizable_good(good_addr);
}
return good_addr;
}
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数初中级Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则近万的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-QNr3FrTm-1713401206362)]
[外链图片转存中…(img-3Yk5fTql-1713401206363)]
[外链图片转存中…(img-Wc98rWla-1713401206364)]
[外链图片转存中…(img-XFKNA4eg-1713401206365)]
[外链图片转存中…(img-Iq06IqqU-1713401206366)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注:Android)
最后
对于程序员来说,要学习的知识内容、技术有太多太多,要想不被环境淘汰就只有不断提升自己,从来都是我们去适应环境,而不是环境来适应我们!
最后,我再重复一次,如果你想成为一个优秀的 Android 开发人员,请集中精力,对基础和重要的事情做深度研究。
对于很多初中级Android工程师而言,想要提升技能,往往是自己摸索成长,不成体系的学习效果低效漫长且无助。整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路,本文的重点是你有没有收获与成长,其余的都不重要,希望读者们能谨记这一点。
为了大家能够顺利进阶中高级、架构师,我特地为大家准备了一套高手学习的源码和框架视频等精品Android架构师教程,保证你学了以后保证薪资上升一个台阶。
以下是今天给大家分享的一些独家干货:
[外链图片转存中…(img-rAY287uv-1713401206367)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!