How to change Volley request rate

Question

I'm making multiple requests to Amazon Web Services. I'm getting the 503 error because I'm making too many request too quickly. I want to know how to set the time-out between different requests, not the same ones. I am not looking to set the retry policy. I am also not looking to time-trigger individual requests. I want to time the interval between requests. The reason is that I am looping so quickly and making so many requests, that timing-triggering them is equivalent to submitting them all that the same time. The whole point is to space the requests out evenly.

Answer 1

assuming you have Request object , before adding the request to the queue you can do this

request.setRetryPolicy(new DefaultRetryPolicy(5000, 5, DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));

the 5000 indicates the time between each request in ms the 5 is the number of times you want to send the request before it gives you timeout

for the sake of someone seeing this, this is how to use timers to manually seclude a task

 Timer timer = new Timer();
    final Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            // Update UI here if u need
        }
    };
    TimerTask task = new TimerTask () {
        @Override
        public void run () {
           //send requests according to your logic here
        }
    };
    timer.schedule(task, 0, 60000); // 60000 = 1 min

Answer 2

Since you don't show how you made multiple requests, so I suggest you refer to the following sample, then try applying to your code. Hope it helps!

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);            

        final RequestQueue queue = Volley.newRequestQueue(this);
        final String url = "http://google.com";
        final Handler handler = new Handler();
        for (int i = 0; i <= 5; i++) {
            handler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    StringRequest request = new StringRequest(url, new Response.Listener<String>() {
                        @Override
                        public void onResponse(String response) {
                            Log.i("onResponse", response);                                
                        }
                    }, new Response.ErrorListener() {
                        @Override
                        public void onErrorResponse(VolleyError error) {
                            Log.e("onErrorResponse", error.toString());
                        }
                    });    
                    queue.add(request);
                }
            }, 2000); // 2000 miliseconds
        }
    }

Answer 3

Was struggling with this too, til I got some help from another developer. Try something like this:

public class HTTP {
    String getUrl;
    Context context;
    YTVisualizer ytv;
    int numberOfCurrentRequests = 0;

    public HTTP(Context context, YTVisualizer ytv){
        this.context = context;
        this.ytv = ytv;
    }

    public void get(final String url) {
        numberOfCurrentRequests++;

        new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(250 * numberOfCurrentRequests);
                } catch(InterruptedException e) {
                    e.printStackTrace();
                }

                // Instantiate the RequestQueue.
                RequestQueue queue = Volley.newRequestQueue(context);

                String[] parts = url.split("=");
                final String key = parts[1];

                // Request a string response from the provided URL.
                StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
                        new Response.Listener<String>() {
                            @Override
                            //runs in thread main
                            public void onResponse(String response) {
                                Log.i("Response", response);

                                String title = new String();

                                try {
                                    JSONObject obj = new JSONObject(response);
                                    Iterator<String> str = obj.keys();
                                    String key = str.next();
                                    title = obj.getString(key);

                                } catch (JSONException e) {
                                    e.printStackTrace();
                                }

                                ytv.SetVideosFromHTTPClass(key, title, response);

                                numberOfCurrentRequests--;
                            }
                        }, new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        Toast.makeText(context, "Error: are you connected to the internet?", Toast.LENGTH_SHORT).show();
                        numberOfCurrentRequests--;
                    }
                });

                // Add the request to the RequestQueue.
                queue.add(stringRequest);
            }
        }).start();
    }
}

It pauses inbetween proportional to the amount of current requests. The 1st one sleeps .25 s, the 2nd one .5s, the third one .75s, and so on. Theyre all scheduled in order.

Answer 4

I know this is an old question, but here is a solution written in Kotlin:

Inside your class with the RequestQueue, you can add

val throttleTimeout : Long = 100L
private val throttleQueue : ArrayBlockingQueue<Request<*>> = ArrayBlockingQueue(100);
private val throttleThread = Thread {
    while(true){
        val rqst = throttleQueue.take()
        requestQueue?.add(rqst)
        Thread.sleep(throttleTimeout)
    }
}

fun <T> addToThrottledRequestQueue(request: Request<T>, tag: String){
    request.tag = if (TextUtils.isEmpty(tag)) TAG else tag
    throttleQueue.put(request)
}

And just make sure to start the thread in your class initialization. You can also mix this with a function to create non-throttled request and mix them together.

fun <T> addToRequestQueue(request: Request<T>, tag: String) {
    request.tag = if (TextUtils.isEmpty(tag)) TAG else tag
    requestQueue?.add(request)
}

The addToThrottledRequestQueue function will make sure those requests are throttled while other requests can flow freely.