JVM对象内存回收可以使用引用计数法和可达性分析算法两种方式来实现。

1. 引用计数法

引用计数法是一种最简单的内存回收算法，它通过在对象中添加一个计数器来记录对象被引用的次数。每当一个新的引用指向该对象时，计数器就会加1；当一个引用不再指向该对象时，计数器就会减1。当计数器的值为0时，即表示该对象没有任何引用指向它，可以被回收。

下面是一个示例代码，模拟了引用计数算法的实现：

class RefCountObject {
    private int count = 0;

    public void addRef() {
        count++;
    }

    public int releaseRef() {
        return --count;
    }

    public int getCount() {
        return count;
    }
}

class Test {
    public static void main(String[] args) {
        RefCountObject obj1 = new RefCountObject();
        RefCountObject obj2 = new RefCountObject();

        obj1.addRef();
        obj2.addRef();
        obj1.addRef();

        System.out.println("obj1 ref count: " + obj1.getCount()); // output: 2
        System.out.println("obj2 ref count: " + obj2.getCount()); // output: 1

        obj1.releaseRef();
        System.out.println("obj1 ref count: " + obj1.getCount()); // output: 1

        obj1.releaseRef();
        obj2.releaseRef();
        System.out.println("obj1 ref count: " + obj1.getCount()); // output: 0
        System.out.println("obj2 ref count: " + obj2.getCount()); // output: 0
    }
}

引用计数法的优点是实现简单、回收及时，可以减少垃圾回收器的压力，但它存在一个致命缺陷：无法处理循环引用的情况。例如，当两个对象相互引用时，它们的计数器值都不为0，即使它们已经无法被访问到，也无法被回收。因此，现代JVM中一般不采用引用计数法进行内存回收。

下面是引用计数法的示例代码：

public class ReferenceCountingGC {
    public Object instance = null;
    private static final int _1MB = 1024 * 1024;
    // 模拟占用内存空间，便于观察GC日志
    private byte[] bigSize = new byte[2 * _1MB];

    public static void main(String[] args) {
        ReferenceCountingGC objA = new ReferenceCountingGC();
        ReferenceCountingGC objB = new ReferenceCountingGC();
        objA.instance = objB;
        objB.instance = objA;
        objA = null;
        objB = null;
        System.gc();
    }
}

在该示例中，创建了两个对象objA和objB，并将它们相互引用。当将objA和objB置为null时，由于它们的引用计数器值都为1，因此无法被回收。

2. 可达性分析算法

可达性分析算法是JVM中主要的垃圾回收算法之一。它的核心思想是通过一系列称为“GC Roots”的根对象作为起点，对所有从根对象开始，能够到达的对象进行标记，那些未标记的对象则被视为无用对象，需要被回收。

GC Roots包括以下几种类型：

1. 虚拟机栈中引用的对象。
2. 方法区中类静态属性引用的对象。
3. 方法区中常量引用的对象。
4. 本地方法栈中JNI(Native方法)引用的对象。

可达性分析算法的优点是能够准确地识别出所有无用的对象，无死角地进行垃圾回收。同时，在执行垃圾回收时只需要扫描从GC Roots开始的对象，大大减少了扫描对象的数量，提高了回收效率。

以下是一个简单的示例代码来说明可达性分析算法的优点：

public class ReachabilityAnalysisGC {
    public static void main(String[] args) {
        ObjectA objA = new ObjectA();
        ObjectB objB = new ObjectB(objA);
        objA = null;
        System.gc();
        System.out.println("objA has been cleared by GC.");
    }

    static class ObjectA {
        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("ObjectA finalize.");
        }
    }

    static class ObjectB {
        private ObjectA a;

        public ObjectB(ObjectA a) {
            this.a = a;
        }

        @Override
        protected void finalize() throws Throwable {
            super.finalize();
            System.out.println("ObjectB finalize.");
        }
    }
}

在该示例中，创建了一个对象objA和一个对象objB，对象objB的构造函数中引用了objA。然后将objA置为null，表示不再引用该对象。在执行System.gc()时，JVM会自动执行一次垃圾回收。由于objA已经不再被引用，因此被视为无用对象，会被回收。在执行回收操作之前，会先执行ObjectA的finalize()方法，输出"ObjectA finalize."。最后输出"objA has been cleared by GC."。

可达性分析算法的缺点是在处理循环引用的情况时，可能会存在一些无法回收的对象。如果两个对象互相引用，但是两个对象都没有被GC Roots引用，那么这两个对象就会被视为无用对象。但实际上它们互相引用，应该互相保留。为了解决这个问题，一般需要结合其他算法进行处理，例如引用计数算法。