Question

我正在使用一个作业队列库，您可以在其中定义Job并将其发布到JobManager。 JobManager有ThreadGroup个工作人员将Job从队列中拉出来并致电Job.onRun()。

通过给出最大和最小线程数量，加载因子（工作者线程在创建新线程之前可以有多少个未完成的作业）和任何高于min的线程的空闲超时来设置线程数量。因此，如果没有新作业，并且达到其空闲超时，则工作线程run()将终止。

在某些Job中我使用的库只显示异步API。在onRun（）中使用它们是否安全？

例如，如果我想发出一个网络请求，它接受一个回调，它会给我一个响应，将调用回调函数：

@Override
public void onRun() throws Throwable {
    client.doRequest(request, new Callback() {
        @Override
        public void onRequestComplete(Response response) {
            //is this guaranteed to get called?
        }
    });
    //since we now return from onRun() will onRequestComplete() get called?
}

Answer 1

是的，只要进程仍然存在，您的回调就会运行。

如果你想看到我创建了一个程序来模拟那个。它有三个类，只需将它们放在任何一个包中运行，你就会看到自己。这甚至表明即使您的作业线程完成回调仍然存在。我希望它有所帮助：）

第1课

public class Client {
    private static long startTime = System.currentTimeMillis();

    public static void main(String[] args) {
        System.out.println("Time elapsed in ms:" + (System.currentTimeMillis() - startTime));
        Client client = new Client();
        client.executeJob();
        try {
            System.out.println("Main thread sleeping");
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Main thread finishing");
    }

    public void executeJob() {
        new Thread() {
            @Override
            public void run() {
                Job job = new Job();
                System.out.println("Calling Job with Asyc - Time elapsed in ms:" 
                        + (System.currentTimeMillis() - startTime));
                job.doRequest("Calling Async", new CallBack() {

                    @Override
                    public void onRequestComplete(String response) {
                        System.out.println("Got my callback eventhough job that started the Async is over - Time elapsed in ms:" 
                                + (System.currentTimeMillis() - startTime));
                    }
                });
                System.out.println("Job thread finishing");
            }
        }.start();
    }
}

第2课

public abstract class CallBack {
    public abstract void onRequestComplete(String response);
}

第3类

public class Job {
    public void doRequest(String request, final CallBack callBack){
        new Thread() {
            @Override
            public void run() {
                //Async Long running task
                try {
                    Thread.sleep(10000);
                    callBack.onRequestComplete("Long Async task Completed-- Sending response back");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }.start();
    }
}

Answer 2

是和否

是：您向Callback对象提供了client的实例。客户端只需在获得响应后（从服务器）调用onRequestComplete方法。

NO：如果没有更多的Thread在运行并且有未完成的请求，它们可能会被取消，因为应用程序将被停止。

但我认为你问的是正常执行而不是关闭JVM。

所以我的猜测是是，但我不知道客户端的实现（我猜它启动了一个内部有某种事件机制的线程）。

Answer 3

只要您知道以下情况属实（过程有效），这样做是安全的：

每个作业的onRun()方法将始终执行（最终），
您使用的每个异步API 始终调用其回调方法（即使存在例外情况）。

运行后执行线程中的Java回调执行（）

3 个答案: