Java、Android、线程安全的关于内存的唯一操作

在我的应用程序中，我需要执行一些长时间运行的任务。我需要它能够从具有独立生命周期的不同程序组件（特别是Android应用程序的活动和服务组件）以及不同线程访问。同时，我不需要经常执行这个操作，因此我不想污染内存。所以我开发了某种自动关闭的单例，但我不确定我是否做对了，我的解决方案也不会有任何问题。所以我在寻找一些专业知识。解决方案如下所示：

public class UniqueOperation {

    private static volatile UniqueOperation instance = null;
    private static final Object lock = new Object();

    private volatile int connections;
    private volatile boolean isRunning;

    private UniqueOperation() {}

    public static UniqueOperation getInstance() {
        synchronized (lock) {
            if (instance == null) {
               instance = new UniqueOperation();
            }
            instance.connections++;
        }
        return instance;
    }

    public void requestWork() {
        synchronized (lock) {
            if (isRunning) {
                return;
            } else {
                isRunning = true;
            }
        }

        doWork();

        synchronized (lock) {
            isRunning = false;
            if (connections < 1) {
                instance = null;
            }
        }
    }

    private void doWork() {
        try {
            Thread.sleep(TimeUnit.MINUTES.toMillis(2));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public boolean isRunning() {
       synchronized (lock) {
           return isRunning;
       }
    }

    public void close() {
        synchronized (lock) {
            connections--;
            if (connections < 1 && !isRunning) {
                instance = null;
            }
        }
    }
}

公共类唯一操作{
私有静态易失性UniqueOperation实例=null；
私有静态最终对象锁=新对象（）；
私有易失性int连接；
私有易失性布尔运算正在运行；
专用唯一操作（）{}
公共静态UniqueOperation getInstance（）{
已同步（锁定）{
if（实例==null）{
实例=新的唯一操作（）；
}
instance.connections++；
}
返回实例；
}
公共工程（）{
已同步（锁定）{
如果（正在运行）{
返回；
}否则{
isRunning=true；
}
}
销钉（）；
已同步（锁定）{
isRunning=false；
如果（连接<1）{
实例=null；
}
}
}
私房{
试一试{
线程。睡眠（时间单位。分钟。托米利斯（2））；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
公共布尔值正在运行（）{
已同步（锁定）{
返回正在运行；
}
}
公众假期结束（）{
已同步（锁定）{
联系--；
if（连接<1&！正在运行）{
实例=null；
}
}
}
}

一旦组件不再需要实例，任何获得实例的组件都应该调用

close（）

---

我优先考虑的是唯一性、线程安全和内存使用

这属于代码复查堆栈交换。有关如何构思好问题的详细信息，请参见和。即便如此，谁会叫这个？您担心的是什么？性能、线程安全等？对所有变量的访问都是通过

synchronized

块正确同步的，因此我认为所有

volatile

声明都是多余的