10个避免Java内存泄露的最佳实践分享

// 不推荐的方式
public void readFile(String path) throws IOException {
    FileInputStream fis = new FileInputStream(path);
    // 使用fis读取文件
    // 如果这里发生异常，fis可能不会被关闭
}

// 推荐的方式：使用try-with-resources
public void readFile(String path) throws IOException {
    try (FileInputStream fis = new FileInputStream(path)) {
        // 使用fis读取文件
    } // fis会自动关闭，即使发生异常
}

public class CacheManager {
    // 静态集合可能导致内存泄漏
    private static final Map<String, Object> cache = new HashMap<>();
    
    public static void addToCache(String key, Object value) {
        cache.put(key, value);
    }
    
    // 确保提供清理机制
    public static void removeFromCache(String key) {
        cache.remove(key);
    }
    
    public static void clearCache() {
        cache.clear();
    }
}

public class Outer {
    private byte[] data = new byte[100000]; // 大对象
    
    // 不推荐：非静态内部类
    public class Inner {
        public void process() {
            System.out.println(data.length);
        }
    }
    
    // 推荐：静态内部类
    public static class StaticInner {
        private final Outer outer;
        
        public StaticInner(Outer outer) {
            this.outer = outer;
        }
        
        public void process() {
            System.out.println(outer.data.length);
        }
    }
}

public class Person {
    private String name;
    private int age;
    
    // 构造函数、getter和setter省略
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class ImageCache {
    // 使用WeakHashMap，当键不再被引用时，对应的条目会被自动移除
    private final Map<String, WeakReference<BufferedImage>> cache = new WeakHashMap<>();
    
    public BufferedImage getImage(String path) {
        WeakReference<BufferedImage> reference = cache.get(path);
        BufferedImage image = (reference != null) ? reference.get() : null;
        
        if (image == null) {
            image = loadImage(path);
            cache.put(path, new WeakReference<>(image));
        }
        
        return image;
    }
    
    private BufferedImage loadImage(String path) {
        // 加载图片的代码
        return null; // 实际应用中返回加载的图片
    }
}

// 不推荐
public class ResourceHolder {
    private FileInputStream fis;
    
    public ResourceHolder(String path) throws IOException {
        fis = new FileInputStream(path);
    }
    
    @Override
    protected void finalize() throws Throwable {
        if (fis != null) {
            fis.close();
        }
        super.finalize();
    }
}

​​​​​​​// 推荐：实现AutoCloseable接口
public class ResourceHolder implements AutoCloseable {
    private FileInputStream fis;
    
    public ResourceHolder(String path) throws IOException {
        fis = new FileInputStream(path);
    }
    
    @Override
    public void close() throws IOException {
        if (fis != null) {
            fis.close();
            fis = null;
        }
    }
}

public class ThreadLocalExample {
    // 定义ThreadLocal变量
    private static final ThreadLocal<byte[]> threadLocalBuffer = 
        ThreadLocal.withInitial(() -> new byte[1024 * 1024]); // 1MB buffer
    
    public void process() {
        // 使用ThreadLocal变量
        byte[] buffer = threadLocalBuffer.get();
        // 处理逻辑...
        
        // 重要：使用完毕后清理ThreadLocal变量
        threadLocalBuffer.remove();
    }
}

// 潜在问题：Parent和Child相互引用
public class Parent {
    private List<Child> children = new ArrayList<>();
    
    public void addChild(Child child) {
        children.add(child);
        child.setParent(this);
    }
}

public class Child {
    private Parent parent;
    
    public void setParent(Parent parent) {
        this.parent = parent;
    }
}

​​​​​​​// 解决方案：使用弱引用打破循环
public class Child {
    private WeakReference<Parent> parentRef;
    
    public void setParent(Parent parent) {
        this.parentRef = new WeakReference<>(parent);
    }
    
    public Parent getParent() {
        return (parentRef != null) ? parentRef.get() : null;
    }
}

// 使用Guava Cache库实现带有大小限制和过期时间的缓存
LoadingCache<Key, Value> cache = CacheBuilder.newBuilder()
    .maximumSize(1000) // 最多缓存1000个条目
    .expireAfterWrite(10, TimeUnit.MINUTES) // 写入10分钟后过期
    .removalListener(notification -> {
        // 可选：处理被移除的条目
        System.out.println("Removed: " + notification.getKey() + " due to " + notification.getCause());
    })
    .build(new CacheLoader<Key, Value>() {
        @Override
        public Value load(Key key) throws Exception {
            // 加载数据的逻辑
            return null; // 实际应用中返回加载的值
        }
    });

// 在关键点手动触发垃圾回收和内存使用情况打印（仅用于开发和调试）
System.gc();
Runtime runtime = Runtime.getRuntime();
long usedMemory = runtime.totalMemory() - runtime.freeMemory();
System.out.println("Used Memory: " + (usedMemory / 1024 / 1024) + " MB");