常见GC算法和垃圾收集器

Java垃圾回收机制深度解析
第一章 垃圾回收基础理论
1.1 对象生命周期管理

Java对象从创建到回收经历三个阶段：

对象分配‌：通过new关键字在堆内存创建
对象使用‌：被线程栈中的引用持有
对象回收‌：失去所有引用后被GC回收
java
Copy Code
public class ObjectLifecycle {
    public static void main(String[] args) {
        // 阶段1：对象分配
        Person p = new Person("张三");
        
        // 阶段2：对象使用
        System.out.println(p.getName());
        
        // 阶段3：对象回收
        p = null; // 取消引用
        System.gc(); // 建议触发GC
    }
}

class Person {
    private String name;
    
    public Person(String name) {
        this.name = name;
    }
    
    // getter/setter省略
}

1.2 可达性分析算法

Java采用根搜索算法(GC Roots Tracing)判定对象存活：

GC Roots包括‌：
虚拟机栈中引用的对象
方法区静态属性引用的对象
方法区常量引用的对象
JNI引用的Native对象
java
Copy Code
public class ReachabilityAnalysis {
    private static Object staticObj = new Object();
    
    public static void main(String[] args) {
        Object stackObj = new Object();
        
        new Thread(() -> {
            Object threadObj = new Object();
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

第二章 经典GC算法实现
2.1 标记-清除算法
java
Copy Code
/**
 * 模拟标记-清除算法实现
 */
public class MarkSweepGC {
    private List<MemoryBlock> memory;
    
    public void gc() {
        // 标记阶段
        mark();
        
        // 清除阶段
        sweep();
    }
    
    private void mark() {
        // 从GC Roots开始遍历标记
        for (MemoryBlock block : memory) {
            if (block.isReachable() && !block.isMarked()) {
                block.setMarked(true);
                // 递归标记引用对象
                markReferencedObjects(block);
            }
        }
    }
    
    private void sweep() {
        Iterator<MemoryBlock> it = memory.iterator();
        while (it.hasNext()) {
            MemoryBlock block = it.next();
            if (!block.isMarked()) {
                it.remove(); // 回收内存
            } else {
                block.setMarked(false); // 重置标记
            }
        }
    }
}

2.2 分代收集算法
java
Copy Code
/**
 * 分代GC模拟实现
 */
public class GenerationalGC {
    private YoungGeneration youngGen;
    private OldGeneration oldGen;
    
    public void minorGC() {
        // 年轻代GC
        youngGen.markAndCopy();
    }
    
    public void majorGC() {
        // 老年代GC
        oldGen.markAndSweep();
    }
    
    public void fullGC() {
        // 整堆GC
        minorGC();
        majorGC();
    }
}

第三章 HotSpot垃圾收集器
3.1 Serial收集器
java
Copy Code
/**
 * 串行GC测试案例
 */
public class SerialGCDemo {
    public static void main(String[] args) {
        // JVM参数：-XX:+UseSerialGC -Xms50m -Xmx50m
        List<byte[]> list = new ArrayList<>();
        
        while (true) {
            byte[] data = new byte[1 * 1024 * 1024]; // 1MB
            list.add(data);
            
            if (list.size() > 40) {
                list.clear();
                System.out.println("GC清理...");
            }
        }
    }
}

3.2 G1收集器
java
Copy Code
/**
 * G1GC测试案例
 */
public class G1GCDemo {
    public static void main(String[] args) {
        // JVM参数：-XX:+UseG1GC -Xms2g -Xmx2g -XX:MaxGCPauseMillis=200
        Map<Integer, String> dataMap = new HashMap<>();
        Random random = new Random();
        
        while (true) {
            for (int i = 0; i < 100000; i++) {
                dataMap.put(i, "Value-" + random.nextInt());
            }
            
            if (random.nextInt(100) > 80) {
                dataMap.clear();
                System.out.println("Map cleared at " + System.currentTimeMillis());
            }
        }
    }
}

第四章 内存分配与回收策略
4.1 对象优先在Eden分配
java
Copy Code
/**
 * 新生代内存分配测试
 */
public class EdenAllocation {
    private static final int _1MB = 1024 * 1024;
    
    public static void main(String[] args) {
        byte[] allocation1, allocation2, allocation3, allocation4;
        allocation1 = new byte[2 * _1MB];
        allocation2 = new byte[2 * _1MB];
        allocation3 = new byte[2 * _1MB];
        allocation4 = new byte[4 * _1MB]; // 触发Minor GC
    }
}

4.2 大对象直接进入老年代
java
Copy Code
/**
 * 大对象分配测试
 */
public class BigObjectAllocation {
    private static final int _1MB = 1024 * 1024;
    
    public static void main(String[] args) {
        // JVM参数：-XX:PretenureSizeThreshold=3145728
        byte[] allocation = new byte[4 * _1MB]; // 直接分配在老年代
    }
}

第五章 GC日志分析实战
5.1 日志格式解析
java
Copy Code
/**
 * 生成GC日志示例
 */
public class GenerateGCLog {
    public static void main(String[] args) {
        // JVM参数：
        // -Xms20m -Xmx20m -XX:+PrintGCDetails 
        // -XX:+PrintGCDateStamps -Xloggc:gc.log
        
        List<byte[]> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add(new byte[1024 * 1024]);
            if (i % 50 == 0) {
                list.clear();
            }
        }
    }
}

5.2 日志分析工具
java
Copy Code
/**
 * 简易GC日志分析器
 */
public class GCLogAnalyzer {
    public static void main(String[] args) throws IOException {
        Path logPath = Paths.get("gc.log");
        List<String> lines = Files.readAllLines(logPath);
        
        int minorGCCount = 0;
        int fullGCCount = 0;
        long totalPauseTime = 0;
        
        for (String line : lines) {
            if (line.contains("GC")) {
                if (line.contains("Full GC")) {
                    fullGCCount++;
                } else {
                    minorGCCount++;
                }
                
                // 提取暂停时间
                String[] parts = line.split(" ");
                for (String part : parts) {
                    if (part.endsWith("secs]")) {
                        double seconds = Double.parseDouble(
                            part.substring(1, part.indexOf("secs")));
                        totalPauseTime += seconds * 1000; // 转毫秒
                    }
                }
            }
        }
        
        System.out.println("Minor GC次数: " + minorGCCount);
        System.out.println("Full GC次数: " + fullGCCount);
        System.out.println("总暂停时间: " + totalPauseTime + "ms");
    }
}

第六章 调优实战案例
6.1 高并发服务调优
java
Copy Code
/**
 * 电商服务GC调优案例
 */
public class EcommerceService {
    // JVM参数：
    // -Xms4g -Xmx4g -XX:+UseG1GC 
    // -XX:MaxGCPauseMillis=200 -XX:ParallelGCThreads=8
    
    private static final ConcurrentHashMap<Long, Product> cache = 
        new ConcurrentHashMap<>();
    
    public Product getProduct(long id) {
        return cache.computeIfAbsent(id, this::loadFromDB);
    }
    
    private Product loadFromDB(long id) {
        // 模拟数据库查询
        return new Product(id, "Product-" + id, new BigDecimal("99.99"));
    }
}

6.2 大数据处理调优
java
Copy Code
/**
 * 大数据批处理GC调优案例
 */
public class BigDataProcessor {
    // JVM参数：
    // -Xms8g -Xmx8g -XX:+UseParallelGC 
    // -XX:ParallelGCThreads=12 -XX:NewRatio=1
    
    public void process(List<DataRecord> records) {
        records.parallelStream()
               .map(this::transform)
               .forEach(this::save);
    }
    
    private DataRecord transform(DataRecord record) {
        // 数据转换逻辑
        return record;
    }
    
    private void save(DataRecord record) {
        // 存储逻辑
    }
}