How the Garbage Collector Works in Java, Python, and Go!

Key Takeaways

copies collection makes programming in mod languages a lot easier at its core it's about reclaiming memory that's no longer in use by a program but why does it matter with effective memory management programs can gradually eat up more and more memory leading to slower performance crashes and outright failure today we're diving into what garbage collection is and how it works in popular languages at is hard garbage collection revolves around simple question which objects in memory do the program still use this question is answered through the concept of reachability every program has GC Roots these are starting points like Global variables and stack references any object that can be reached by following references from these routs is considered alive and must be kept everything else is garbage ready to be collected to efficiently manage memory garbage collector typically Implement a generational hierarchy this design is based on an empirical observation most objects die in Java version machine memory is divided into three main areas the Young Generation old generation and metaspace new objects start life in the Young generation's Eden space if they survive multiple collection Cycles they graduate to the Survivor space within the Young Generation the rare objects that persist even longer earn promotion to the old generation where collection happens less frequently but more thoroughly the metaspace is Java specific used for class metadata to help reduce memory footprint in large applications other languages might Implement generational collection differently for instance V8 uses a two generation system and net garbage collector typically uses three generations numbers 0 1 and two the most fundamental garbage collector strategy is to Mark and sweep algorithm it works in two phases first during the mark phase it traverses all references starting from the GC routs marking each reachable object then in the sweep phase it reclaims memory from any unmarked objects while effective this basic approach requires the application to completely pause during collection known as a stop the world pause which can freeze the applications for noticeable periods of time these paes become more problematic as Heap sizes grow and applications demand better responsiveness an enhanced version called a triol mark and sweep algorithm reduces these process by categorizing objects into three sets white objects are considered potential garbage gray objects are known to be reachable but haven't been fully explored black objects are both reachable and fully processed by maintaining these three distinct sets the garbage collector can pause briefly to do initial marking then continue examining gray objects and their references while the application runs this incremental approach avoids the long pause required by tra traditional Mark and sweep where the entire object graph must be traced at once languages take different approaches to garbage collection Java for instance offers several GC algorithms serial parallel CMS and G1 the evolution of these algorithms reflects the need to balance performance latency and scalability across different application types they're designed to handle everything from small scale apps to massive Enterprise systems often using a general generational model to optimize performance python uses a combination of reference counting and a cyclic garbage collector the reference counting handles most cases by automatically deallocating objects when their reference can drops to zero The cyli Collector cleans up circular references which reference counting alone can manage Go uses a concurrent Mark in sweep collector which operates alongside the application to minimize pause times it leverages a tricolor marking algorithm mentioned before to handle reachability efficiently this allows garbage collection to proceed incrementally without significantly disrupting application performance as helpful as garbage collection is is not without drawbacks for one there's the performance overhead GC Cycles can introduce unpredictable passes which may not matter for some applications but could be a problem for latency sensitive systems there's also memory fragmentation some collectors leave gaps in memory making allocation slower over time memory management also involves balancing used pool and free pools to ensure efficient allocation and deallocation without fragmentation with garbage collection we usually lose fine green control over when cleanup happens this can lead to unpredictable poses in your application if you like a video you might like a system design newsletter as well it covers topics and Trends in large scale system design trusted by 1 million readers subscribed at blog. byby go.com