run()后执行的线程中的Java回调执行

Question

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

线程的数量是通过给定线程的最大和最小数量、负载因子(一个工作线程在创建一个新线程之前可以有多少未完成的作业)和超过最小值的任何线程的空闲超时来设置的。因此，如果工作线程的 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();
    }
}