内存泄漏：Java应用中常见内存泄露案例-蒲公英云

内存泄漏：Java应用中常见内存泄露案例

内存泄露在Java应用开发中是一个常见的问题，它会导致可用内存逐渐减少，影响程序性能甚至导致系统崩溃。以下是一些典型的Java内存泄露案例：

静态变量引用：如果某个类的某个方法返回一个静态对象，并且这个对象没有被正确释放，就会形成内存泄露。

public class StaticRefLeak {
    private static final MyClass instance;
    static {
        instance = new MyClass(); // 这里产生了问题
    }
    public static MyClass getInstance() {
        return instance;
    }
}

循环引用：当两个对象相互引用，形成循环引用时，无法自然地释放其中一个对象，从而造成内存泄露。

class CycleRefLeak {
    private Node node1, node2;
    public void addNode(Node node) {
        if (node == null || node1 != null && node1.equals(node)) {
            return;
        }
        switch (node.getDegree()) {
            case 0:
                node1 = node;
                break;
            case 1:
                node2 = node;
                addEdge(node1, node2);
                break;
            default:
                for (Node neighbor : node.getNeighbors()) {
                    addEdge(node1, neighbor);
                    addEdge(neighbor, node2));
                }
                break;
        }
    }
    // Node类，包含degree属性和getNeighbors方法
    private static class Node {
        private int degree;
        private List<Node> neighbors;
        public Node(int degree) {
            this.degree = degree;
            this.neighbors = new ArrayList<>();
          }
        ...
      }
    ...
    // 添加多条边
    public void addEdges(Node node1, Node node2, Node... nodesToConnect) {
        for (Node currentNode : nodesToConnect) {
            if (! currentNode.equals(node1)) && ! currentNode.equals(node2)) {
                addEdge(node1, currentNode);
                addEdge(currentNode, node2));
            }
        }
    }
    // 用于添加边的方法
    private void addEdge(Node node1, Node node2)) {
        if (node1 != null && node2 != null) {
            node1.getNeighbors().add(node2);
            node2.getNeighbors().add(node1);
          } else {
            System.out.println("Invalid node passed to addEdge() method.");
          }
        return;
    }
}