Java 如何编写可中断方法

我有一个方法，从概念上看，它类似于：

Object f(Object o1) {
    Object o2 = longProcess1(o1);
    Object o3 = longProcess2(o2);
    return longProcess3(o3);
}

Object f(Object o1) {
    Object o2 = longProcess1(o1);
    if (Thread.interrupted()) throw new InterruptedException();
    Object o3 = longProcess2(o2);
    if (Thread.interrupted()) throw new InterruptedException();
    return longProcess3(o3);
}

Object longProcess1(Object o1) {
    Object o2 = longSubProcess1(o1);
    if (Thread.interrupted()) throw new InterruptedException();
    return longSubProcess2(o2);
}

...

过程本身也可能是复合的：

Object longProcess1(Object o1) {
    Object o2 = longSubProcess1(o1);
    return longSubProcess2(o2);
}

以此类推，不同的进程可能位于不同的模块中。大多数进程都很长，因为它们在计算上很昂贵，不受IO限制

到目前为止还不错，但现在我希望

f

作为一个整体是可中断的。是使用

Thread.interrupted（）

定期检查中断标志。这非常简单，但如果我需要将方法更改为以下内容，它可能会很快变得很麻烦：

Object f(Object o1) {
    Object o2 = longProcess1(o1);
    Object o3 = longProcess2(o2);
    return longProcess3(o3);
}

Object f(Object o1) {
    Object o2 = longProcess1(o1);
    if (Thread.interrupted()) throw new InterruptedException();
    Object o3 = longProcess2(o2);
    if (Thread.interrupted()) throw new InterruptedException();
    return longProcess3(o3);
}

Object longProcess1(Object o1) {
    Object o2 = longSubProcess1(o1);
    if (Thread.interrupted()) throw new InterruptedException();
    return longSubProcess2(o2);
}

...

现在，我确实理解这样工作的合理性——它允许我更好地控制何时抛出InterruptedException（例如），避免让对象处于不一致的状态——但是我想知道是否有一种更优雅的方法来这样做*

---

*在Java中，不是AspectJ，我想这在这里是非常合适的，但我坚持使用Java。

您可以使用接口和动态代理：

public class Wrapper {
    public static <T> T wrap(Class<T> intf, final T impl) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        Object proxy = Proxy.newProxyInstance(cl, new Class<?>[] {intf},
                new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                if (Thread.interrupted()) {
                    throw new InterruptedException();
                }
                return method.invoke(impl, args);
            }
        });
        return intf.cast(proxy);
    }
}

interface Processes {
    Object longProcess1(Object o);
    ...
}

public class ProcessesImpl implement Processes {
    Processes self = Wrapper.wrap(Processes.class, this);

    public Object f(Object o1) {
        Object o2 = self.longProcess1(o1);
        Object o3 = self.longProcess2(o2);
        return self.longProcess3(o3);
    }

    public Object longProcess1(Object o1) {
        Object o2 = self.longSubProcess1(o1);
        return self.longSubProcess2(o2);
    }

    ....
}

公共类包装器{
公共静态T换行（类intf，最终T impl）{
ClassLoader cl=Thread.currentThread（）.getContextClassLoader（）；
objectproxy=proxy.newProxyInstance（cl，新类[]{intf}，
新的调用处理程序（）{
公共对象调用（对象代理、方法、对象[]参数）
扔掉的{
if（Thread.interrupted（））{
抛出新的InterruptedException（）；
}
返回方法.invoke（impl，args）；
}
});
返回intf.cast（代理）；
}
}
接口过程{
对象1（对象o）；
...
}
公共类进程Impl实现进程{
processs self=Wrapper.wrap（processs.class，this）；
公共对象f（对象o1）{
对象o2=自我长过程1（o1）；
对象o3=自身长过程2（o2）；
返回自我长过程3（o3）；
}
公共对象longProcess1（对象o1）{
对象o2=self.longSubProcess1（o1）；
返回自长子进程2（o2）；
}
....
}

我是否正确地理解了您顺序运行相同嵌套级别的方法？如果是这样，为什么不将计算方法实现为

java.lang.Runnable

实例，将它们组织到列表中并在循环中启动它们呢？然后，您将只有一个位置具有

Thread.interrupted（）

check

您可以考虑使用<代码> java .UTI.Orth.ExtutoService < /C>以促进对计算任务的控制。 更新了一个示例：

import java.util.ArrayList;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        List<CompoundProcess> subProcesses1 = new ArrayList<CompoundProcess>();
        subProcesses1.add(new CompoundProcess() {
            public void run() {
                System.out.println("Process 1.1");
            }
        });
        subProcesses1.add(new CompoundProcess() {
            public void run() {
                System.out.println("Process 1.2");
            }
        });

        List<CompoundProcess> subProcesses2 = new ArrayList<CompoundProcess>();
        subProcesses2.add(new CompoundProcess() {
            public void run() {
                System.out.println("Process 2.1");
            }
        });
        subProcesses2.add(new CompoundProcess() {
            public void run() {
                System.out.println("Process 2.2");
            }
        });

        List<CompoundProcess> processes1 = new ArrayList<CompoundProcess>() {};
        processes1.add(new CompoundProcess(subProcesses1));
        processes1.add(new CompoundProcess(subProcesses2));

        CompoundProcess process = new CompoundProcess(processes1);
        process.run();
    }


    static class CompoundProcess implements Runnable {

        private List<CompoundProcess> processes = new ArrayList<CompoundProcess>();

        public CompoundProcess() {
        }

        public CompoundProcess(List<CompoundProcess> processes) {
            this.processes = processes;
        }

        public void run() {
            for (Runnable process : processes) {
                if (Thread.interrupted()) {
                    throw new RuntimeException("The processing was interrupted");
                } else {
                    process.run();
                }
            }
        }
    }

}

import java.util.ArrayList；
导入java.util.List；
公开课考试{
公共静态void main（字符串[]args）{
列表子流程1=新建ArrayList（）；
子流程1.add（新的CompoundProcess（）{
公开募捐{
系统输出打印项次（“过程1.1”）；
}
});
子流程1.add（新的CompoundProcess（）{
公开募捐{
系统输出打印项次（“过程1.2”）；
}
});
列表子进程2=新建ArrayList（）；
子流程2.add（新的CompoundProcess（）{
公开募捐{
系统输出打印项次（“过程2.1”）；
}
});
子流程2.add（新的CompoundProcess（）{
公开募捐{
System.out.println（“过程2.2”）；
}
});
列表进程1=新的ArrayList（）{}；
processes1.add（新的CompoundProcess（subProcesses1））；
流程1.添加（新的复合流程（子流程2））；
复合流程=新的复合流程（流程1）；
process.run（）；
}
静态类CompoundProcess实现可运行{
私有列表进程=新的ArrayList（）；
公共复合过程（）{
}
公共复合流程（列出流程）{
这个过程=过程；
}
公开募捐{
for（可运行进程：进程）{
if（Thread.interrupted（））{
抛出新的RuntimeException（“处理被中断”）；
}否则{
process.run（）；
}
}
}
}
}

我会担心包含相互引用的线程的代码会出现死锁。不，进程在许多不同的地方-我试图通过显示

longProcess1

本身是复合的来演示它，也许我不够清楚，所以我对问题进行了编辑以澄清。一旦同一级别的进程按顺序运行，它们在不同的位置启动就没有多大关系了。我用一个例子更新了我的答案。您可以将进程嵌套到您想要的级别。这很有趣，但仍然有点麻烦。我需要为所有相关类添加一个字段，并限定许多方法调用。结果的方法更优雅，不过，我会给你！