java仿C++模拟实现一个智能指针

public interface SmartPointer<T> {
    T get();                    // 获取底层对象
    void retain();             // 增加引用计数
    void release();            // 减少引用计数，必要时触发清理
    int useCount();            // 当前引用计数
    boolean isValid();         // 底层资源是否仍可用
}

// =================================================================
// 文件：SmartPointer.java
// 包名：com.example.smartptr
// 功能：通用智能指针接口
// =================================================================
package com.example.smartptr;
 
public interface SmartPointer<T> {
    /** 返回被管理的对象，若已清理则抛异常 */
    T get();
    /** 增加引用计数 */
    void retain();
    /** 减少引用计数，必要时触发清理 */
    void release();
    /** 当前引用计数 */
    int useCount();
    /** 对象是否仍未被清理 */
    boolean isValid();
}
 
// =================================================================
// 文件：AbstractRefCountedPointer.java
// 包名：com.example.smartptr
// 功能：带引用计数与清理回调的抽象基类
// =================================================================
package com.example.smartptr;
 
import java.util.concurrent.atomic.AtomicInteger;
 
public abstract class AbstractRefCountedPointer<T> implements SmartPointer<T> {
    protected final T referent;
    private final AtomicInteger refCount = new AtomicInteger(1);
    private final Runnable cleanup;
    private volatile boolean valid = true;
 
    protected AbstractRefCountedPointer(T referent, Runnable cleanup) {
        if (referent == null) throw new IllegalArgumentException("Referent cannot be null");
        this.referent = referent;
        this.cleanup  = cleanup;
    }
 
    @Override
    public T get() {
        if (!valid) throw new IllegalStateException("Resource already released");
        return referent;
    }
 
    @Override
    public void retain() {
        if (!valid) throw new IllegalStateException("Cannot retain released resource");
        refCount.incrementAndGet();
    }
 
    @Override
    public void release() {
        int rc = refCount.decrementAndGet();
        if (rc < 0) throw new IllegalStateException("release() called too many times");
        if (rc == 0) {
            valid = false;
            cleanup.run();
        }
    }
 
    @Override
    public int useCount() {
        return refCount.get();
    }
 
    @Override
    public boolean isValid() {
        return valid;
    }
}
 
// =================================================================
// 文件：RefCountedPointer.java
// 包名：com.example.smartptr
// 功能：普通对象的引用计数智能指针
// =================================================================
package com.example.smartptr;
 
public class RefCountedPointer<T> extends AbstractRefCountedPointer<T> {
    public RefCountedPointer(T referent, Runnable cleanup) {
        super(referent, cleanup != null ? cleanup : () -> {});
    }
    public RefCountedPointer(T referent) {
        this(referent, () -> {});
    }
}
 
// =================================================================
// 文件：AutoClosePointer.java
// 包名：com.example.smartptr
// 功能：自动关闭 AutoCloseable 资源的智能指针
// =================================================================
package com.example.smartptr;
 
public class AutoClosePointer<T extends AutoCloseable>
        extends AbstractRefCountedPointer<T> {
    public AutoClosePointer(T referent) {
        super(referent, () -> {
            try { referent.close(); }
            catch (Exception e) { /* 可记录日志 */ }
        });
    }
}
 
// =================================================================
// 文件：WeakSmartPointer.java
// 包名：com.example.smartptr
// 功能：弱引用智能指针，资源被 GC 回收时触发回调
// =================================================================
package com.example.smartptr;
 
import java.lang.ref.*;
import java.util.concurrent.*;
 
public class WeakSmartPointer<T> implements SmartPointer<T> {
    private final WeakReference<T> weakRef;
    private final ReferenceQueue<T> queue = new ReferenceQueue<>();
    private final Runnable cleanup;
    private volatile boolean valid = true;
 
    public WeakSmartPointer(T referent, Runnable cleanup) {
        this.weakRef = new WeakReference<>(referent, queue);
        this.cleanup = cleanup != null ? cleanup : () -> {};
        startWatcher();
    }
 
    private void startWatcher() {
        Thread watcher = new Thread(() -> {
            try {
                Reference<? extends T> r = queue.remove();
                if (r == weakRef) {
                    valid = false;
                    cleanup.run();
                }
            } catch (InterruptedException ignored) {}
        }, "WeakPtr-Watcher");
        watcher.setDaemon(true);
        watcher.start();
    }
 
    @Override
    public T get() {
        T t = weakRef.get();
        if (t == null) throw new IllegalStateException("Resource already GCed");
        return t;
    }
 
    @Override
    public void retain() {
        throw new UnsupportedOperationException("WeakSmartPointer does not support retain()");
    }
 
    @Override
    public void release() {
        throw new UnsupportedOperationException("WeakSmartPointer does not support release()");
    }
 
    @Override
    public int useCount() {
        return valid && weakRef.get() != null ? 1 : 0;
    }
 
    @Override
    public boolean isValid() {
        return valid && weakRef.get() != null;
    }
}
 
// =================================================================
// 文件：Main.java
// 包名：com.example.smartptr
// 功能：示例演示各种智能指针的使用场景
// =================================================================
package com.example.smartptr;
 
import java.io.*;
 
public class Main {
    public static void main(String[] args) throws Exception {
        System.out.println("=== RefCountedPointer 示例 ===");
        RefCountedPointer<StringBuilder> p = new RefCountedPointer<>(
            new StringBuilder("Hello"), () -> System.out.println("Cleanup called"));
        System.out.println("useCount=" + p.useCount());
        p.retain();
        System.out.println("useCount after retain=" + p.useCount());
        p.release();
        System.out.println("useCount after release=" + p.useCount());
        p.release(); // 最后一次，触发 cleanup
        System.out.println("isValid=" + p.isValid());
 
        System.out.println("\n=== AutoClosePointer 示例 ===");
        AutoClosePointer<FileInputStream> ap =
            new AutoClosePointer<>(new FileInputStream("test.txt"));
        FileInputStream fis = ap.get();
        System.out.println("File opened? " + (fis != null));
        ap.release(); // 自动 close()
 
        System.out.println("\n=== WeakSmartPointer 示例 ===");
        Object obj = new Object();
        WeakSmartPointer<Object> wp = new WeakSmartPointer<>(obj,
            () -> System.out.println("Weak cleanup called"));
        System.out.println("isValid before GC=" + wp.isValid());
        obj = null;
        System.gc(); Thread.sleep(100);
        System.out.println("isValid after GC=" + wp.isValid());
    }
}