同时发送2个post请求，等待最多80毫秒的响应

Question

我正在尝试发送两个post请求。两者应该同时发送(在我下面的当前代码中，可能是一个接一个地发送)，并且应该等待最大80毫秒的响应，如果请求没有响应，则认为响应为空。

public void SendRequests(String requestString){

    TimeLimiter limiter1 = new SimpleTimeLimiter();
    Response response1 = null;
    System.out.println("Request Sent to 1");
    try{
        response1 = limiter1.callWithTimeout(new Callable<Response>() {
        public Response call() {

            //assume sendPost1 method will send POST request to some server and return response from server

            return sendPost1(requestString);
        }
      }, 80, TimeUnit.MILLISECONDS, true);
    }catch(Exception te){
        te.printStackTrace();
    }

    TimeLimiter limiter2 = new SimpleTimeLimiter();
    Response response2 = null;
    System.out.println("Request Sent to 2");
    try{
        response2 = limiter2.callWithTimeout(new Callable<Response>() {
            public Response call() {

                //assume sendPost2 method will send POST request to some server and return response from server


                return sendPost2(requestString);
            }
        }, 80, TimeUnit.MILLISECONDS, true);
    }catch(Exception te){
        te.printStackTrace();
    }

    //Do some process using response1 and response2

    }
}

我正在寻找一些方法来同时发送2个帖子请求并等待80ms的响应，如果没有响应，则将响应视为空。

@格雷，我试过你的解决方案如下。最初几分钟，我的servlet响应时间是2ms-10ms，但之后，它突然增加到200-300ms。

@WebServlet("/incomingTraffic")
public class ServletClass  extends HttpServlet {
Gson gson;
private static URL url1;
private static URL url2;

public Exchanger() {
    super();
}
public void init(ServletConfig config) throws ServletException {
    gson = new Gson();

    try{

    url1 = new URL( Constants.URL1 );
    url2 = new URL( Constants.URL2 );

    }catch(Exception e){

    } 

}

public void destroy() {
}

protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    response.getWriter().append("Served at: ").append(request.getContextPath());
}

protected void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    ServletInputStream inputStream = request.getInputStream();
    Reader reader = new InputStreamReader(inputStream);

    //Request class is POJO
    final Request requestString = gson.fromJson(reader, Request.class);

    reader.close();
    //long start = System.currentTimeMillis();
    TimeLimiter limiter = new SimpleTimeLimiter();

    //Response class is POJO
    Response response1 = null;
    Response response2 = null;

    final ExecutorService threadPool = Executors.newCachedThreadPool();

    Future<Response> future1 = threadPool.submit(new Callable<Response>() {
        public Response call() {
            return sendPost1(requestString);
        }
    });
    Future<Response> future2 = null;

    if(Some Condition Satisfy){
        future2 = threadPool.submit(new Callable<Response>() {
            public Response call() {
                return sendPost2(requestString);
            }
        });
    }
    threadPool.shutdown();

    long start = System.currentTimeMillis();
    try {
        response1 = future1.get(80, TimeUnit.MILLISECONDS);
    } catch (ExecutionException ee) {
       // job threw exception
    } catch (InterruptedException ie) {
       // this (main?) thread was interrupted, good pattern to re-interupt
       Thread.currentThread().interrupt();
    } catch (TimeoutException te) {
       // wait timed out, maybe this is right?
        response1 = null;
       // try to interrupt the thread
       future1.cancel(true);
    }

    if(requestString.getImp().get(0).getVideo() != null){
    // wait for 80 MILLISECONDS minus how long we've been waiting for 2nd request
    long end = System.currentTimeMillis();
    //System.out.println(start+" - "+end);
    long wait = 80 + start - end;
    if (wait < 0) {
       wait = 0;
    }

    try {
        response2 = future2.get(wait, TimeUnit.MILLISECONDS);
    } catch (ExecutionException ee) {
       // job threw exception
    } catch (InterruptedException ie) {
       // this (main?) thread was interrupted, good pattern to re-interrupt
       Thread.currentThread().interrupt();
    } catch (TimeoutException te) {
       // wait timed out, maybe this is right?
        response2 = null;
       // try to interrupt the thread
       future2.cancel(true);
    }
    }
    try {
        threadPool.awaitTermination(80, TimeUnit.MILLISECONDS);
    } catch (InterruptedException e) {

    }

    if(response1 == null && response2 == null){
        response.setStatus(HttpServletResponse.SC_NO_CONTENT);
    }else {
        response.setContentType("application/json");
        PrintWriter output = response.getWriter();
        response.setStatus(HttpServletResponse.SC_OK);
        if(Some Condition){
            response.getWriter().write(gson.toJson(response1));
        }
        else{
            response.getWriter().write(gson.toJson(response1));
        }
    }
        output.flush();
        output.close();
    }
}

protected Response sendPost2(Request request){
    Response response = null;
    String str = gson.toJson(request);
    HttpURLConnection conn = null;
    try{
        conn= (HttpURLConnection) url2.openConnection();           
        conn.setDoOutput( true );
        conn.setInstanceFollowRedirects( false );
        conn.setRequestMethod( "POST" );
        conn.setRequestProperty( "Content-Type", "application/json");
        conn.setRequestProperty("Connection", "keep-alive");
        conn.setRequestProperty( "Content-Length", Integer.toString(str.length()));

        DataOutputStream wr = new DataOutputStream(conn.getOutputStream());
        wr.writeBytes(str);
        wr.flush();
        wr.close();

        int responseCode = conn.getResponseCode();

        if(responseCode != 200){
            return null;
        }

        Reader reader = new InputStreamReader(conn.getInputStream());
        response = gson.fromJson(reader, Response.class);
        conn.disconnect();
    }catch(Exception e){
        e.printStackTrace();
        conn.disconnect();
    }

    return response;
}

protected Response sendPost1(Request request){
    Response response = null;
    String str = gson.toJson(request);
    HttpURLConnection conn = null;
    try{
        conn= (HttpURLConnection) url1.openConnection();           
        conn.setDoOutput( true );
        conn.setInstanceFollowRedirects( false );
        conn.setRequestMethod( "POST" );
        conn.setRequestProperty( "Content-Type", "application/json");
        conn.setRequestProperty("Connection", "keep-alive");
        conn.setRequestProperty( "Content-Length", Integer.toString(str.length()));

        DataOutputStream wr = new DataOutputStream(conn.getOutputStream());
        wr.writeBytes(str);
        wr.flush();
        wr.close();

        int responseCode = conn.getResponseCode();

        if(responseCode != 200){
            return null;
        }

        Reader reader = new InputStreamReader(conn.getInputStream());
        response = gson.fromJson(reader, Response.class);
        conn.disconnect();

    }catch(Exception e){
        e.printStackTrace();
        conn.disconnect();
    }

    return response;
}

}

Answer 1

我正在寻找一些方法来同时发送2个帖子请求并等待80ms的响应，如果没有响应，则将响应视为空。

您当然可以将两者都作为Callable提交

final ExecutorService threadPool = Executors.newCachedThreadPool(NUM_THREADS);
...
Future<Response> future1 = threadPool.submit(new Callable<>() { ... });
Future<Response> future2 = threadPool.submit(new Callable<>() { ... });
// once you have submitted the last job you can shutdown the pool
threadPool.shutdown();

long start = System.currentTimeMillis();
try {
   response1 = future1.get(80, TimeUnit.SECONDS);
} catch (ExecutionException ee) {
   // job threw exception
} catch (InterruptedExeception ie) {
   // this (main?) thread was interrupted, good pattern to re-interupt
   Thread.currentThread().interrupt();
} catch (TimeoutException te) {
   // wait timed out, maybe this is right?
   response1 = null;
   // try to interrupt the thread
   future1.cancel(true);
}

// wait for 80 seconds minus how long we've been waiting for 2nd request
long wait = System.currentTimeMillis() - start - 80000;
if (wait < 0) {
   wait = 0;
}
try {
   response2 = future2.get(wait, TimeUnit.MILLISECONDS);
} catch (ExecutionException ee) {
   // job threw exception
} catch (InterruptedExeception ie) {
   // this (main?) thread was interrupted, good pattern to re-interrupt
   Thread.currentThread().interrupt();
} catch (TimeoutException te) {
   // wait timed out, maybe this is right?
   response2 = null;
   // try to interrupt the thread
   future2.cancel(true);
}

这将很好地工作，但诀窍是中断2个请求。仅仅中断线程不会杀死任何网络套接字或数据库连接。您必须确保作业可以自行测试中断状态，否则可能会泄漏线程。